Move remaining files in content\browser\renderer_host to content namespace.

content/browser/renderer_host/render_widget_host_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 "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/shared_memory.h"
 #include "base/timer.h"
 #include "content/browser/browser_thread_impl.h"
 #include "content/browser/renderer_host/backing_store.h"
@@ skipping 18 matching lines @@
 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
 #include "ui/aura/env.h"
 #endif
 
 #if defined(OS_WIN) || defined(USE_AURA)
 #include "content/browser/renderer_host/ui_events_helper.h"
 #include "ui/base/events/event.h"
 #endif
 
 using base::TimeDelta;
-using content::BackingStore;
-using content::BrowserThread;
-using content::BrowserThreadImpl;
-using content::GestureEventFilter;
-using content::MockRenderProcessHost;
-using content::NativeWebKeyboardEvent;
-using content::RenderWidgetHost;
-using content::RenderWidgetHostImpl;
 using WebKit::WebGestureEvent;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseWheelEvent;
 using WebKit::WebTouchEvent;
 using WebKit::WebTouchPoint;
 
-namespace gfx {
-class Size;
-}
+namespace content {
 
 #if defined(OS_WIN) || defined(USE_AURA)
 bool TouchEventsAreEquivalent(const ui::TouchEvent& first,
                               const ui::TouchEvent& second) {
   EXPECT_EQ(second.type(), first.type());
   if (first.type() != second.type())
     return false;
   EXPECT_EQ(second.location().ToString(), first.location().ToString());
   if (first.location() != second.location())
     return false;
@@ skipping 21 matching lines @@
   }
 
   return true;
 }
 #endif  // defined(OS_WIN) || defined(USE_AURA)
 
 // RenderWidgetHostProcess -----------------------------------------------------
 
 class RenderWidgetHostProcess : public MockRenderProcessHost {
  public:
-  explicit RenderWidgetHostProcess(content::BrowserContext* browser_context)
+  explicit RenderWidgetHostProcess(BrowserContext* browser_context)
       : MockRenderProcessHost(browser_context),
         current_update_buf_(NULL),
         update_msg_should_reply_(false),
         update_msg_reply_flags_(0) {
   }
   ~RenderWidgetHostProcess() {
     delete current_update_buf_;
   }
 
   void set_update_msg_should_reply(bool reply) {
@@ skipping 58 matching lines @@
 
   ViewHostMsg_UpdateRect message(render_widget_id, params);
   *msg = message;
   return true;
 }
 
 // TestView --------------------------------------------------------------------
 
 // This test view allows us to specify the size, and keep track of acked
 // touch-events.
-class TestView : public content::TestRenderWidgetHostView {
+class TestView : public TestRenderWidgetHostView {
  public:
   explicit TestView(RenderWidgetHostImpl* rwh)
-      : content::TestRenderWidgetHostView(rwh),
+      : TestRenderWidgetHostView(rwh),
         acked_event_count_(0) {
   }
 
   // Sets the bounds returned by GetViewBounds.
   void set_bounds(const gfx::Rect& bounds) {
     bounds_ = bounds;
   }
 
   const WebTouchEvent& acked_event() const { return acked_event_; }
   int acked_event_count() const { return acked_event_count_; }
@@ skipping 15 matching lines @@
  protected:
   WebTouchEvent acked_event_;
   int acked_event_count_;
   gfx::Rect bounds_;
 
   DISALLOW_COPY_AND_ASSIGN(TestView);
 };
 
 // MockRenderWidgetHostDelegate --------------------------------------------
 
-class MockRenderWidgetHostDelegate : public content::RenderWidgetHostDelegate {
+class MockRenderWidgetHostDelegate : public RenderWidgetHostDelegate {
  public:
   MockRenderWidgetHostDelegate()
       : prehandle_keyboard_event_(false),
         prehandle_keyboard_event_called_(false),
         prehandle_keyboard_event_type_(WebInputEvent::Undefined),
         unhandled_keyboard_event_called_(false),
         unhandled_keyboard_event_type_(WebInputEvent::Undefined) {
   }
   virtual ~MockRenderWidgetHostDelegate() {}
 
@@ skipping 40 matching lines @@
 
   bool unhandled_keyboard_event_called_;
   WebInputEvent::Type unhandled_keyboard_event_type_;
 };
 
 // MockRenderWidgetHost ----------------------------------------------------
 
 class MockRenderWidgetHost : public RenderWidgetHostImpl {
  public:
   MockRenderWidgetHost(
-      content::RenderWidgetHostDelegate* delegate,
-      content::RenderProcessHost* process,
+      RenderWidgetHostDelegate* delegate,
+      RenderProcessHost* process,
       int routing_id)
       : RenderWidgetHostImpl(delegate, process, routing_id),
         unresponsive_timer_fired_(false) {
   }
 
   // Allow poking at a few private members.
   using RenderWidgetHostImpl::OnMsgPaintAtSizeAck;
   using RenderWidgetHostImpl::OnMsgUpdateRect;
   using RenderWidgetHostImpl::RendererExited;
   using RenderWidgetHostImpl::in_flight_size_;
@@ skipping 54 matching lines @@
   virtual void NotifyRendererUnresponsive() OVERRIDE {
     unresponsive_timer_fired_ = true;
   }
 
  private:
   bool unresponsive_timer_fired_;
 };
 
 // MockPaintingObserver --------------------------------------------------------
 
-class MockPaintingObserver : public content::NotificationObserver {
+class MockPaintingObserver : public NotificationObserver {
  public:
   void WidgetDidReceivePaintAtSizeAck(RenderWidgetHostImpl* host,
                                       int tag,
                                       const gfx::Size& size) {
     host_ = reinterpret_cast<MockRenderWidgetHost*>(host);
     tag_ = tag;
     size_ = size;
   }
 
   void Observe(int type,
-               const content::NotificationSource& source,
-               const content::NotificationDetails& details) {
-    if (type ==
-        content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK) {
+               const NotificationSource& source,
+               const NotificationDetails& details) {
+    if (type == NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK) {
       std::pair<int, gfx::Size>* size_ack_details =
-          content::Details<std::pair<int, gfx::Size> >(details).ptr();
+          Details<std::pair<int, gfx::Size> >(details).ptr();
       WidgetDidReceivePaintAtSizeAck(
-          RenderWidgetHostImpl::From(
-              content::Source<RenderWidgetHost>(source).ptr()),
+          RenderWidgetHostImpl::From(Source<RenderWidgetHost>(source).ptr()),
           size_ack_details->first,
           size_ack_details->second);
     }
   }
 
   MockRenderWidgetHost* host() const { return host_; }
   int tag() const { return tag_; }
   gfx::Size size() const { return size_; }
 
  private:
   MockRenderWidgetHost* host_;
   int tag_;
   gfx::Size size_;
 };
 
 
 // RenderWidgetHostTest --------------------------------------------------------
 
 class RenderWidgetHostTest : public testing::Test {
  public:
   RenderWidgetHostTest() : process_(NULL) {
   }
   ~RenderWidgetHostTest() {
   }
 
  protected:
   // testing::Test
   void SetUp() {
-    browser_context_.reset(new content::TestBrowserContext());
+    browser_context_.reset(new TestBrowserContext());
     delegate_.reset(new MockRenderWidgetHostDelegate());
     process_ = new RenderWidgetHostProcess(browser_context_.get());
     host_.reset(
         new MockRenderWidgetHost(delegate_.get(), process_, MSG_ROUTING_NONE));
     view_.reset(new TestView(host_.get()));
     host_->SetView(view_.get());
     host_->Init();
   }
   void TearDown() {
     view_.reset();
@@ skipping 108 matching lines @@
   }
 
   void ReleaseTouchPoint(int index) {
     CHECK(index >= 0 && index < touch_event_.touchesLengthCap);
     touch_event_.touches[index].state = WebKit::WebTouchPoint::StateReleased;
     touch_event_.type = WebInputEvent::TouchEnd;
   }
 
   MessageLoopForUI message_loop_;
 
-  scoped_ptr<content::TestBrowserContext> browser_context_;
+  scoped_ptr<TestBrowserContext> browser_context_;
   RenderWidgetHostProcess* process_;  // Deleted automatically by the widget.
   scoped_ptr<MockRenderWidgetHostDelegate> delegate_;
   scoped_ptr<MockRenderWidgetHost> host_;
   scoped_ptr<TestView> view_;
 
  private:
   WebTouchEvent touch_event_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostTest);
 };
@@ skipping 107 matching lines @@
   EXPECT_FALSE(host_->resize_ack_pending_);
   EXPECT_EQ(gfx::Size(), host_->in_flight_size_);
 
   // Reset the view so we can exit the test cleanly.
   host_->SetView(view_.get());
 }
 
 // Tests setting custom background
 TEST_F(RenderWidgetHostTest, Background) {
 #if !defined(OS_MACOSX)
-  scoped_ptr<content::RenderWidgetHostView> view(
-      content::RenderWidgetHostView::CreateViewForWidget(host_.get()));
+  scoped_ptr<RenderWidgetHostView> view(
+      RenderWidgetHostView::CreateViewForWidget(host_.get()));
 #if defined(OS_LINUX) || defined(USE_AURA)
   // TODO(derat): Call this on all platforms: http://crbug.com/102450.
   // InitAsChild doesn't seem to work if NULL parent is passed on Windows,
   // which leads to DCHECK failure in RenderWidgetHostView::Destroy.
   // When you enable this for OS_WIN, enable |view.release()->Destroy()|
   // below.
   view->InitAsChild(NULL);
 #endif
   host_->SetView(view.get());
 
@@ skipping 29 matching lines @@
   sent_background.a.lockPixels();
   EXPECT_TRUE(0 == memcmp(background.getPixels(),
                           sent_background.a.getPixels(),
                           background.getSize()));
   sent_background.a.unlockPixels();
   background.unlockPixels();
 
 #if defined(OS_LINUX) || defined(USE_AURA)
   // See the comment above |InitAsChild(NULL)|.
   host_->SetView(NULL);
-  static_cast<content::RenderWidgetHostViewPort*>(view.release())->Destroy();
+  static_cast<RenderWidgetHostViewPort*>(view.release())->Destroy();
 #endif
 
 #else
   // TODO(port): Mac does not have gfx::Canvas. Maybe we can just change this
   // test to use SkCanvas directly?
 #endif
 
   // TODO(aa): It would be nice to factor out the painting logic so that we
   // could test that, but it appears that would mean painting everything twice
   // since windows HDC structures are opaque.
@@ skipping 95 matching lines @@
   EXPECT_TRUE(needs_repaint.a);
 }
 
 TEST_F(RenderWidgetHostTest, PaintAtSize) {
   const int kPaintAtSizeTag = 42;
   host_->PaintAtSize(TransportDIB::GetFakeHandleForTest(), kPaintAtSizeTag,
                      gfx::Size(40, 60), gfx::Size(20, 30));
   EXPECT_TRUE(
       process_->sink().GetUniqueMessageMatching(ViewMsg_PaintAtSize::ID));
 
-  content::NotificationRegistrar registrar;
+  NotificationRegistrar registrar;
   MockPaintingObserver observer;
   registrar.Add(
       &observer,
-      content::NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
-      content::Source<RenderWidgetHost>(host_.get()));
+      NOTIFICATION_RENDER_WIDGET_HOST_DID_RECEIVE_PAINT_AT_SIZE_ACK,
+      Source<RenderWidgetHost>(host_.get()));
 
   host_->OnMsgPaintAtSizeAck(kPaintAtSizeTag, gfx::Size(20, 30));
   EXPECT_EQ(host_.get(), observer.host());
   EXPECT_EQ(kPaintAtSizeTag, observer.tag());
   EXPECT_EQ(20, observer.size().width());
   EXPECT_EQ(30, observer.size().height());
 }
 
 // Fails on Linux Aura, see http://crbug.com/100344
 #if defined(USE_AURA) && !defined(OS_WIN)
@@ skipping 813 matching lines @@
   WebInputEvent::Type acks[] = { WebInputEvent::TouchStart,
                                  WebInputEvent::TouchMove,
                                  WebInputEvent::TouchStart,
                                  WebInputEvent::TouchMove };
 
   for (size_t i = 0; i < arraysize(acks); ++i) {
     SendInputEventACK(acks[i], false);
     EXPECT_EQ(acks[i], view_->acked_event().type);
     ScopedVector<ui::TouchEvent> acked;
 
-    content::MakeUITouchEventsFromWebTouchEvents(view_->acked_event(), &acked);
+    MakeUITouchEventsFromWebTouchEvents(view_->acked_event(), &acked);
     bool success = EventListIsSubset(acked, expected_events);
     EXPECT_TRUE(success) << "Failed on step: " << i;
     if (!success)
       break;
     expected_events.erase(expected_events.begin(),
                           expected_events.begin() + acked.size());
   }
 
   EXPECT_EQ(0U, expected_events.size());
 }
@@ skipping 77 matching lines @@
 TEST_F(RenderWidgetHostTest, IncorrectBitmapScaleFactor) {
   ViewHostMsg_UpdateRect_Params params;
   process_->InitUpdateRectParams(&params);
   params.scale_factor = params.scale_factor * 2;
 
   EXPECT_EQ(0, process_->bad_msg_count());
   host_->OnMsgUpdateRect(params);
   EXPECT_EQ(1, process_->bad_msg_count());
 }
 #endif
+
+}  // namespace content