Move content\browser\renderer_host\media to content namespace.

content/browser/renderer_host/media/web_contents_video_capture_device.cc

 // Copyright (c) 2012 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.
 //
 // Implementation notes: This needs to work on a variety of hardware
 // configurations where the speed of the CPU and GPU greatly affect overall
 // performance.  Therefore, the process of capturing has been split up into a
 // pipeline of three stages.  Each stage executes on its own thread:
 //
 //   1. Capture: A bitmap is snapshotted/copied from the RenderView's backing
@@ skipping 124 matching lines @@
   }
   // Make each dimension a positive, even number; if not already.
   fitted_width = std::max(kMinFrameWidth, MakeEven(fitted_width));
   fitted_height = std::max(kMinFrameHeight, MakeEven(fitted_height));
 
   *fitted_size = gfx::Size(fitted_width, fitted_height);
 }
 
 // Keeps track of the RenderView to be sourced, and executes copying of the
 // backing store on the UI BrowserThread.
-class BackingStoreCopier : public content::WebContentsObserver {
+class BackingStoreCopier : public WebContentsObserver {
  public:
   // Result status and done callback used with StartCopy().
   enum Result {
     OK,
     TRANSIENT_ERROR,
     NO_SOURCE,
   };
   typedef base::Callback<void(Result result,
                               scoped_ptr<skia::PlatformBitmap> capture,
                               const base::Time& capture_time)> DoneCB;
 
   BackingStoreCopier(int render_process_id, int render_view_id);
 
   // If non-NULL, use the given |override| to access the backing store.
   // This is used for unit testing.
-  void SetRenderWidgetHostForTesting(content::RenderWidgetHost* override);
+  void SetRenderWidgetHostForTesting(RenderWidgetHost* override);
 
   // Starts the copy from the backing store.  Must be run on the UI
   // BrowserThread.  |done_cb| is invoked with result status.  When successful
   // (OK), the bitmap of the capture is transferred to the callback along with
   // the timestamp at which the capture was completed.
   void StartCopy(int desired_width, int desired_height, const DoneCB& done_cb);
 
  private:
   void LookUpAndObserveWebContents();
 
   void CopyFromBackingStoreComplete(scoped_ptr<skia::PlatformBitmap> capture,
                                     const DoneCB& done_cb, bool success);
 
   // The "starting point" to find the capture source.
   const int render_process_id_;
   const int render_view_id_;
 
   // If the following is NULL (normal behavior), the implementation should
   // access RenderWidgetHost via web_contents().
-  content::RenderWidgetHost* rwh_for_testing_;
+  RenderWidgetHost* rwh_for_testing_;
 
   DISALLOW_COPY_AND_ASSIGN(BackingStoreCopier);
 };
 
 // Renders captures (from the backing store) into video frame buffers on a
 // separate thread.  Manages use of internally-owned video frame buffers.
 class VideoFrameRenderer {
  public:
   typedef base::Callback<void(const SkBitmap*)> DoneCB;
 
@@ skipping 71 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameDeliverer);
 };
 
 BackingStoreCopier::BackingStoreCopier(int render_process_id,
                                        int render_view_id)
     : render_process_id_(render_process_id), render_view_id_(render_view_id),
       rwh_for_testing_(NULL) {}
 
 void BackingStoreCopier::LookUpAndObserveWebContents() {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Look-up the RenderViewHost and, from that, the WebContents that wraps it.
   // If successful, begin observing the WebContents instance.  If unsuccessful,
   // stop observing and post an error.
   //
   // Why this can be unsuccessful: The request for mirroring originates in a
   // render process, and this request is based on the current RenderView
   // associated with a tab.  However, by the time we get up-and-running here,
   // there have been multiple back-and-forth IPCs between processes, as well as
   // a bit of indirection across threads.  It's easily possible that, in the
   // meantime, the original RenderView may have gone away.
-  content::RenderViewHost* const rvh =
-      content::RenderViewHost::FromID(render_process_id_, render_view_id_);
+  RenderViewHost* const rvh =
+      RenderViewHost::FromID(render_process_id_, render_view_id_);
   DVLOG_IF(1, !rvh) << "RenderViewHost::FromID("
                     << render_process_id_ << ", " << render_view_id_
                     << ") returned NULL.";
-  Observe(rvh ? content::WebContents::FromRenderViewHost(rvh) : NULL);
+  Observe(rvh ? WebContents::FromRenderViewHost(rvh) : NULL);
   DVLOG_IF(1, !web_contents())
       << "WebContents::FromRenderViewHost(" << rvh << ") returned NULL.";
 }
 
 void BackingStoreCopier::SetRenderWidgetHostForTesting(
-    content::RenderWidgetHost* override) {
+    RenderWidgetHost* override) {
   rwh_for_testing_ = override;
 }
 
 void BackingStoreCopier::StartCopy(int desired_width, int desired_height,
                                    const DoneCB& done_cb) {
-  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   TRACE_EVENT_ASYNC_BEGIN0("mirroring", "Capture", this);
 
-  content::RenderWidgetHost* rwh;
+  RenderWidgetHost* rwh;
   if (rwh_for_testing_) {
     rwh = rwh_for_testing_;
   } else {
     if (!web_contents()) {  // No source yet.
       LookUpAndObserveWebContents();
       if (!web_contents()) {  // No source ever.
         done_cb.Run(NO_SOURCE,
                     scoped_ptr<skia::PlatformBitmap>(NULL), base::Time());
         return;
       }
     }
     rwh = web_contents()->GetRenderViewHost();
     if (!rwh) {
       // Transient failure state (e.g., a RenderView is being replaced).
       done_cb.Run(TRANSIENT_ERROR,
                   scoped_ptr<skia::PlatformBitmap>(NULL), base::Time());
       return;
     }
   }
 
   gfx::Size fitted_size;
-  if (content::RenderWidgetHostView* const view = rwh->GetView()) {
+  if (RenderWidgetHostView* const view = rwh->GetView()) {
     const gfx::Size& view_size = view->GetViewBounds().size();
     if (!view_size.IsEmpty()) {
       CalculateFittedSize(view_size.width(), view_size.height(),
                           desired_width, desired_height,
                           &fitted_size);
     }
   }
 
   // TODO(miu): Look into tweaking the interface to CopyFromBackingStore, since
   // it seems poor to have to allocate a new skia::PlatformBitmap as an output
@@ skipping 261 matching lines @@
 //
 // CaptureMachine manages a simple state machine and the pipeline (see notes at
 // top of this file).  It times the start of successive captures and
 // facilitates the processing of each through the stages of the pipeline.
 class CaptureMachine
     : public base::RefCountedThreadSafe<CaptureMachine, CaptureMachine> {
  public:
   CaptureMachine(int render_process_id, int render_view_id);
 
   // Set capture source to the given |override| for unit testing.
-  void SetRenderWidgetHostForTesting(content::RenderWidgetHost* override);
+  void SetRenderWidgetHostForTesting(RenderWidgetHost* override);
 
   // Synchronously sets/unsets the consumer.  Pass |consumer| as NULL to remove
   // the reference to the consumer; then, once this method returns,
   // CaptureMachine will no longer invoke callbacks on the old consumer from any
   // thread.
   void SetConsumer(media::VideoCaptureDevice::EventHandler* consumer);
 
   // Asynchronous requests to change CaptureMachine state.
   void Allocate(int width, int height, int frame_rate);
   void Start();
@@ skipping 64 matching lines @@
     : manager_thread_("WebContentsVideo_ManagerThread"),
       state_(kIdle),
       is_snapshotting_(false),
       num_renders_pending_(0),
       copier_(render_process_id, render_view_id),
       deliverer_(&consumer_) {
   manager_thread_.Start();
 }
 
 void CaptureMachine::SetRenderWidgetHostForTesting(
-    content::RenderWidgetHost* override) {
+    RenderWidgetHost* override) {
   copier_.SetRenderWidgetHostForTesting(override);
 }
 
 void CaptureMachine::SetConsumer(
     media::VideoCaptureDevice::EventHandler* consumer) {
   consumer_.SetConsumer(consumer);
 }
 
 void CaptureMachine::Allocate(int width, int height, int frame_rate) {
   ENSURE_INVOKED_ON_THREAD(manager_thread_,
@@ skipping 87 matching lines @@
   // point (because CaptureMachine's ref-count is zero).
 }
 
 // static
 void CaptureMachine::Destruct(const CaptureMachine* x) {
   // The current thread is very likely to be one owned by CaptureMachine.  When
   // ~CaptureMachine() is called, it will attempt to join with the
   // CaptureMachine-owned threads, including itself.  Since it's illegal for a
   // thread to join with itself, we need to trampoline the destructor call to
   // another thread.
-  content::BrowserThread::PostBlockingPoolTask(
+  BrowserThread::PostBlockingPoolTask(
       FROM_HERE, base::Bind(&DeleteFromOutsideThread, x));
 }
 
 // static
 void CaptureMachine::DeleteFromOutsideThread(const CaptureMachine* x) {
   // Note: Thread joins are about to happen here (in ~CaptureThread()).
   delete x;
 }
 
 void CaptureMachine::TransitionStateTo(State next_state) {
@@ skipping 52 matching lines @@
   if (!is_snapshotting_) {
     is_snapshotting_ = true;
 
     const BackingStoreCopier::DoneCB& done_cb =
         media::BindToLoop(manager_thread_.message_loop_proxy(),
                           base::Bind(&CaptureMachine::SnapshotComplete, this));
     const base::Closure& start_cb =
             base::Bind(&BackingStoreCopier::StartCopy,
                        base::Unretained(&copier_),
                        settings_.width, settings_.height, done_cb);
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI, FROM_HERE, start_cb);
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE, start_cb);
   }
 
   ScheduleNextFrameCapture();
 }
 
 void CaptureMachine::SnapshotComplete(BackingStoreCopier::Result result,
                                       scoped_ptr<skia::PlatformBitmap> capture,
                                       const base::Time& capture_time) {
   DCHECK_EQ(manager_thread_.message_loop(), MessageLoop::current());
 
@@ skipping 52 matching lines @@
   renderer_.Release(frame_buffer);
 }
 
 WebContentsVideoCaptureDevice::WebContentsVideoCaptureDevice(
     const media::VideoCaptureDevice::Name& name,
     int render_process_id, int render_view_id)
     : device_name_(name),
       capturer_(new CaptureMachine(render_process_id, render_view_id)) {}
 
 WebContentsVideoCaptureDevice::WebContentsVideoCaptureDevice(
-    content::RenderWidgetHost* test_source)
+    RenderWidgetHost* test_source)
     : capturer_(new CaptureMachine(-1, -1)) {
   device_name_.device_name = "WebContentsForTesting";
   device_name_.unique_id = "-1:-1";
   capturer_->SetRenderWidgetHostForTesting(test_source);
 }
 
 WebContentsVideoCaptureDevice::~WebContentsVideoCaptureDevice() {
   DVLOG(2) << "WebContentsVideoCaptureDevice@" << this << " destroying.";
 }
 
@@ skipping 20 matching lines @@
                       "WebContents[%.*s]",
                       static_cast<int>(device_id.size()), device_id.data());
   name.unique_id = device_id;
 
   return new WebContentsVideoCaptureDevice(
       name, render_process_id, render_view_id);
 }
 
 // static
 media::VideoCaptureDevice* WebContentsVideoCaptureDevice::CreateForTesting(
-    content::RenderWidgetHost* test_source) {
+    RenderWidgetHost* test_source) {
   return new WebContentsVideoCaptureDevice(test_source);
 }
 
 void WebContentsVideoCaptureDevice::Allocate(
     int width, int height, int frame_rate,
     VideoCaptureDevice::EventHandler* consumer) {
   DCHECK(capturer_);
   capturer_->SetConsumer(consumer);
   capturer_->Allocate(width, height, frame_rate);
 }
@@ skipping 13 matching lines @@
   capturer_->SetConsumer(NULL);
   capturer_->DeAllocate();
 }
 
 const media::VideoCaptureDevice::Name&
 WebContentsVideoCaptureDevice::device_name() {
   return device_name_;
 }
 
 }  // namespace content