text: // Copyright (c) 2011 The Chromium Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  
  #include "media/video/capture/video_capture_proxy.h"
  
  #include "base/bind.h"
  #include "base/location.h"
  #include "base/message_loop/message_loop_proxy.h"
  #include "media/base/video_frame.h"
  
  namespace {
  
  // Called on VC thread: extracts the state out of the VideoCapture, and
  // serialize it into a VideoCaptureState.
  media::VideoCaptureHandlerProxy::VideoCaptureState GetState(
      media::VideoCapture* capture) {
    media::VideoCaptureHandlerProxy::VideoCaptureState state;
    state.started = capture->CaptureStarted();
    state.frame_rate = capture->CaptureFrameRate();
    return state;
  }
  
  }  // anonymous namespace
  
  namespace media {
  
  VideoCaptureHandlerProxy::VideoCaptureHandlerProxy(
      VideoCapture::EventHandler* proxied,
      scoped_refptr<base::MessageLoopProxy> main_message_loop)
      : proxied_(proxied),
        main_message_loop_(main_message_loop) {
  }
  
  VideoCaptureHandlerProxy::~VideoCaptureHandlerProxy() {
  }
  
  void VideoCaptureHandlerProxy::OnStarted(VideoCapture* capture) {
    main_message_loop_->PostTask(FROM_HERE, base::Bind(
          &VideoCaptureHandlerProxy::OnStartedOnMainThread,
          base::Unretained(this),
          capture,
          GetState(capture)));
  }
  
  void VideoCaptureHandlerProxy::OnStopped(VideoCapture* capture) {
    main_message_loop_->PostTask(FROM_HERE, base::Bind(
          &VideoCaptureHandlerProxy::OnStoppedOnMainThread,
          base::Unretained(this),
          capture,
          GetState(capture)));
  }
  
  void VideoCaptureHandlerProxy::OnPaused(VideoCapture* capture) {
    main_message_loop_->PostTask(FROM_HERE, base::Bind(
        &VideoCaptureHandlerProxy::OnPausedOnMainThread,
        base::Unretained(this),
        capture,
        GetState(capture)));
  }
  
  void VideoCaptureHandlerProxy::OnError(VideoCapture* capture, int error_code) {
    main_message_loop_->PostTask(FROM_HERE, base::Bind(
        &VideoCaptureHandlerProxy::OnErrorOnMainThread,
        base::Unretained(this),
        capture,
        GetState(capture),
        error_code));
  }
  
  void VideoCaptureHandlerProxy::OnRemoved(VideoCapture* capture) {
    main_message_loop_->PostTask(FROM_HERE, base::Bind(
        &VideoCaptureHandlerProxy::OnRemovedOnMainThread,
        base::Unretained(this),
        capture,
        GetState(capture)));
  }
  
  void VideoCaptureHandlerProxy::OnFrameReady(
      VideoCapture* capture,
      const scoped_refptr<VideoFrame>& frame) {
    main_message_loop_->PostTask(
        FROM_HERE,
        base::Bind(&VideoCaptureHandlerProxy::OnFrameReadyOnMainThread,
                   base::Unretained(this),
                   capture,
                   GetState(capture),
                   frame));
  }
  
  void VideoCaptureHandlerProxy::OnStartedOnMainThread(
      VideoCapture* capture,
      const VideoCaptureState& state) {
    state_ = state;
    proxied_->OnStarted(capture);
  }
  
  void VideoCaptureHandlerProxy::OnStoppedOnMainThread(
      VideoCapture* capture,
      const VideoCaptureState& state) {
    state_ = state;
    proxied_->OnStopped(capture);
  }
  
  void VideoCaptureHandlerProxy::OnPausedOnMainThread(
      VideoCapture* capture,
      const VideoCaptureState& state) {
    state_ = state;
    proxied_->OnPaused(capture);
  }
  
  void VideoCaptureHandlerProxy::OnErrorOnMainThread(
      VideoCapture* capture,
      const VideoCaptureState& state,
      int error_code) {
    state_ = state;
    proxied_->OnError(capture, error_code);
  }
  
  void VideoCaptureHandlerProxy::OnRemovedOnMainThread(
      VideoCapture* capture,
      const VideoCaptureState& state) {
    state_ = state;
    proxied_->OnRemoved(capture);
  }
  
  void VideoCaptureHandlerProxy::OnFrameReadyOnMainThread(
      VideoCapture* capture,
      const VideoCaptureState& state,
      const scoped_refptr<VideoFrame>& frame) {
    state_ = state;
    proxied_->OnFrameReady(capture, frame);
  }
  
  }  // namespace media
  