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

content/browser/renderer_host/media/web_contents_video_capture_device_unittest.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.
 
 #include "content/browser/renderer_host/media/web_contents_video_capture_device.h"
 
 #include "base/synchronization/condition_variable.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/render_widget_host_delegate.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/public/test/mock_render_process_host.h"
 #include "content/public/test/test_browser_context.h"
 #include "media/video/capture/video_capture_types.h"
 #include "skia/ext/platform_canvas.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkColor.h"
 
+namespace content {
 namespace {
 const int kTestWidth = 1280;
 const int kTestHeight = 720;
 const int kBytesPerPixel = 4;
 const int kTestFramesPerSecond = 8;
 const SkColor kNothingYet = 0xdeadbeef;
 const SkColor kNotInterested = ~kNothingYet;
 }
 
 // A stub implementation which returns solid-color bitmaps in calls to
 // CopyFromBackingStore().  The unit tests can change the color for successive
 // captures.
-class StubRenderWidgetHost : public content::RenderWidgetHostImpl {
+class StubRenderWidgetHost : public RenderWidgetHostImpl {
  public:
-  StubRenderWidgetHost(content::RenderProcessHost* process,
-                       int routing_id)
+  StubRenderWidgetHost(RenderProcessHost* process, int routing_id)
       : RenderWidgetHostImpl(&delegate_, process, routing_id),
         color_(kNothingYet) {}
 
   void SetSolidColor(SkColor color) {
     color_ = color;
   }
 
   virtual void CopyFromBackingStore(
       const gfx::Rect& src_rect,
       const gfx::Size& accelerated_dst_size,
       const base::Callback<void(bool)>& callback,
       skia::PlatformBitmap* output) OVERRIDE {
     DCHECK(output);
     EXPECT_TRUE(output->Allocate(kTestWidth, kTestHeight, true));
     SkBitmap bitmap = output->GetBitmap();
     {
       SkAutoLockPixels locker(bitmap);
       bitmap.eraseColor(color_);
     }
 
     callback.Run(true);
   }
 
  private:
-  class StubRenderWidgetHostDelegate
-      : public content::RenderWidgetHostDelegate {
+  class StubRenderWidgetHostDelegate : public RenderWidgetHostDelegate {
    public:
     StubRenderWidgetHostDelegate() {}
     virtual ~StubRenderWidgetHostDelegate() {}
 
    private:
     DISALLOW_COPY_AND_ASSIGN(StubRenderWidgetHostDelegate);
   };
 
   StubRenderWidgetHostDelegate delegate_;
   SkColor color_;
@@ skipping 77 matching lines @@
  public:
   WebContentsVideoCaptureDeviceTest() {}
 
  protected:
   virtual void SetUp() {
     // This is a MessageLoop for the current thread.  The MockRenderProcessHost
     // will schedule its destruction in this MessageLoop during TearDown().
     message_loop_.reset(new MessageLoop(MessageLoop::TYPE_IO));
 
     // The CopyFromBackingStore and WebContents tracking occur on the UI thread.
-    ui_thread_.reset(
-        new content::BrowserThreadImpl(content::BrowserThread::UI));
+    ui_thread_.reset(new BrowserThreadImpl(BrowserThread::UI));
     ui_thread_->Start();
 
     // And the rest...
-    browser_context_.reset(new content::TestBrowserContext());
+    browser_context_.reset(new TestBrowserContext());
     source_.reset(new StubRenderWidgetHost(
-        new content::MockRenderProcessHost(browser_context_.get()),
-        MSG_ROUTING_NONE));
-    device_.reset(content::WebContentsVideoCaptureDevice::CreateForTesting(
+        new MockRenderProcessHost(browser_context_.get()), MSG_ROUTING_NONE));
+    device_.reset(WebContentsVideoCaptureDevice::CreateForTesting(
         source_.get()));
     consumer_.reset(new StubConsumer);
   }
 
   virtual void TearDown() {
     // Tear down in opposite order of set-up.
     consumer_.reset();
     device_.reset();
     source_.reset();
     browser_context_.reset();
     ui_thread_->Stop();
     ui_thread_.reset();
     message_loop_->RunAllPending();  // Deletes MockRenderProcessHost.
     message_loop_.reset();
   }
 
   // Accessors.
   StubRenderWidgetHost* source() const { return source_.get(); }
   media::VideoCaptureDevice* device() const { return device_.get(); }
   StubConsumer* consumer() const { return consumer_.get(); }
 
  private:
   scoped_ptr<MessageLoop> message_loop_;
-  scoped_ptr<content::BrowserThreadImpl> ui_thread_;
-  scoped_ptr<content::TestBrowserContext> browser_context_;
+  scoped_ptr<BrowserThreadImpl> ui_thread_;
+  scoped_ptr<TestBrowserContext> browser_context_;
   scoped_ptr<StubRenderWidgetHost> source_;
   scoped_ptr<media::VideoCaptureDevice> device_;
   scoped_ptr<StubConsumer> consumer_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsVideoCaptureDeviceTest);
 };
 
 // The "happy case" test.  No scaling is needed, so we should be able to change
 // the picture emitted from the source and expect to see each delivered to the
 // consumer.
@@ skipping 11 matching lines @@
   source()->SetSolidColor(SK_ColorBLACK);
   EXPECT_TRUE(consumer()->WaitForNextColorOrError(SK_ColorBLACK));
 
   device()->DeAllocate();
 }
 
 TEST_F(WebContentsVideoCaptureDeviceTest, RejectsInvalidAllocateParams) {
   device()->Allocate(1280, 720, -2, consumer());
   EXPECT_FALSE(consumer()->WaitForNextColorOrError(kNotInterested));
 }
+
+}  // namespace content