Move Render(View|Widget)Host and associated classes to content namespace.

content/browser/renderer_host/test_render_view_host.h

 // 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_TEST_RENDER_VIEW_HOST_H_
 #define CONTENT_BROWSER_RENDERER_HOST_TEST_RENDER_VIEW_HOST_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/message_loop.h"
 #include "build/build_config.h"
 #include "content/browser/renderer_host/mock_render_process_host.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/renderer_host/render_widget_host_view_base.h"
 #include "content/public/common/page_transition_types.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+// This file provides a testing framework for mocking out the RenderProcessHost
+// layer. It allows you to test RenderViewHost, TabContents,
+// NavigationController, and other layers above that without running an actual
+// renderer process.
+//
+// To use, derive your test base class from RenderViewHostTestHarness.
+
 #if defined(USE_AURA)
 namespace aura {
 class RootWindow;
 namespace test {
 class TestStackingClient;
 }
 }
 #endif
 
 namespace content {
 class BrowserContext;
 class NavigationController;
 class RenderProcessHostFactory;
 class SiteInstance;
 }
 
 namespace gfx {
 class Rect;
 }
 
 class TestTabContents;
 struct ViewHostMsg_FrameNavigate_Params;
 
+namespace content {
+
 // Utility function to initialize ViewHostMsg_NavigateParams_Params
 // with given |page_id|, |url| and |transition_type|.
 void InitNavigateParams(ViewHostMsg_FrameNavigate_Params* params,
                         int page_id,
                         const GURL& url,
-                        content::PageTransition transition_type);
-
-// This file provides a testing framework for mocking out the RenderProcessHost
-// layer. It allows you to test RenderViewHost, TabContents,
-// NavigationController, and other layers above that without running an actual
-// renderer process.
-//
-// To use, derive your test base class from RenderViewHostTestHarness.
-
-
-namespace content {
+                        PageTransition transition_type);
 
 // TestRenderViewHostView ------------------------------------------------------
 
 // Subclass the RenderViewHost's view so that we can call Show(), etc.,
 // without having side-effects.
 class TestRenderWidgetHostView : public RenderWidgetHostViewBase {
  public:
   explicit TestRenderWidgetHostView(RenderWidgetHost* rwh);
   virtual ~TestRenderWidgetHostView();
 
@@ skipping 19 matching lines @@
 #if defined(TOOLKIT_USES_GTK)
   virtual GdkEventButton* GetLastMouseDown() OVERRIDE;
 #if !defined(TOOLKIT_VIEWS)
   virtual gfx::NativeView BuildInputMethodsGtkMenu() OVERRIDE;
 #endif  // !defined(TOOLKIT_VIEWS)
 #endif  // defined(TOOLKIT_USES_GTK)
   virtual void UnhandledWheelEvent(
       const WebKit::WebMouseWheelEvent& event) OVERRIDE {}
 
   // RenderWidgetHostViewPort implementation.
-  virtual void InitAsPopup(content::RenderWidgetHostView* parent_host_view,
+  virtual void InitAsPopup(RenderWidgetHostView* parent_host_view,
                            const gfx::Rect& pos) OVERRIDE {}
   virtual void InitAsFullscreen(
-      content::RenderWidgetHostView* reference_host_view) OVERRIDE {}
+      RenderWidgetHostView* reference_host_view) OVERRIDE {}
   virtual void DidBecomeSelected() OVERRIDE {}
   virtual void WasHidden() OVERRIDE {}
   virtual void MovePluginWindows(
       const std::vector<webkit::npapi::WebPluginGeometry>& moves) OVERRIDE {}
   virtual void Focus() OVERRIDE {}
   virtual void Blur() OVERRIDE {}
   virtual void SetIsLoading(bool is_loading) OVERRIDE {}
   virtual void UpdateCursor(const WebCursor& cursor) OVERRIDE {}
   virtual void TextInputStateChanged(ui::TextInputType state,
                                      bool can_compose_inline) OVERRIDE {}
@@ skipping 68 matching lines @@
 
   bool is_showing() const { return is_showing_; }
 
  protected:
   RenderWidgetHostImpl* rwh_;
 
  private:
   bool is_showing_;
 };
 
-}  // namespace content
-
 #if defined(COMPILER_MSVC)
 // See comment for same warning on RenderViewHostImpl.
 #pragma warning(push)
 #pragma warning(disable: 4250)
 #endif
 
 // TestRenderViewHost ----------------------------------------------------------
 
 // TODO(brettw) this should use a TestTabContents which should be generalized
 // from the TabContents test. We will probably also need that class' version of
 // CreateRenderViewForRenderManager when more complicate tests start using this.
 class TestRenderViewHost : public RenderViewHostImpl {
  public:
   // If the given TabContnets has a pending RVH, returns it, otherwise NULL.
   static TestRenderViewHost* GetPendingForController(
-      content::NavigationController* controller);
+      NavigationController* controller);
 
-  TestRenderViewHost(content::SiteInstance* instance,
-                     content::RenderViewHostDelegate* delegate,
+  TestRenderViewHost(SiteInstance* instance,
+                     RenderViewHostDelegate* delegate,
                      int routing_id);
   virtual ~TestRenderViewHost();
 
   // Testing functions ---------------------------------------------------------
 
   // Calls the RenderViewHosts' private OnMessageReceived function with the
   // given message.
   bool TestOnMessageReceived(const IPC::Message& msg);
 
   // Calls OnMsgNavigate on the RenderViewHost with the given information,
   // setting the rest of the parameters in the message to the "typical" values.
   // This is a helper function for simulating the most common types of loads.
   void SendNavigate(int page_id, const GURL& url);
 
   // Calls OnMsgNavigate on the RenderViewHost with the given information,
-  // including a custom content::PageTransition.  Sets the rest of the
+  // including a custom PageTransition.  Sets the rest of the
   // parameters in the message to the "typical" values. This is a helper
   // function for simulating the most common types of loads.
   void SendNavigateWithTransition(int page_id, const GURL& url,
-                                  content::PageTransition transition);
+                                  PageTransition transition);
 
   // Calls OnMsgShouldCloseACK on the RenderViewHost with the given parameter.
   void SendShouldCloseACK(bool proceed);
 
   void TestOnMsgStartDragging(const WebDropData& drop_data);
 
   // If set, *delete_counter is incremented when this object destructs.
   void set_delete_counter(int* delete_counter) {
     delete_counter_ = delete_counter;
   }
@@ skipping 63 matching lines @@
   // See set_contents_mime_type() above.
   std::string contents_mime_type_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRenderViewHost);
 };
 
 #if defined(COMPILER_MSVC)
 #pragma warning(pop)
 #endif
 
+}  // namespace content
+
 // TestRenderViewHostFactory ---------------------------------------------------
 
 // Manages creation of the RenderViewHosts using our special subclass. This
 // automatically registers itself when it goes in scope, and unregisters itself
 // when it goes out of scope. Since you can't have more than one factory
 // registered at a time, you can only have one of these objects at a time.
 class TestRenderViewHostFactory : public RenderViewHostFactory {
  public:
   explicit TestRenderViewHostFactory(
       content::RenderProcessHostFactory* rph_factory);
   virtual ~TestRenderViewHostFactory();
 
   virtual void set_render_process_host_factory(
       content::RenderProcessHostFactory* rph_factory);
-  virtual RenderViewHost* CreateRenderViewHost(
+  virtual content::RenderViewHost* CreateRenderViewHost(
       content::SiteInstance* instance,
       content::RenderViewHostDelegate* delegate,
       int routing_id,
       content::SessionStorageNamespace* session_storage) OVERRIDE;
 
  private:
   // This is a bit of a hack. With the current design of the site instances /
   // browsing instances, it's difficult to pass a RenderProcessHostFactory
   // around properly.
   //
   // Instead, we set it right before we create a new RenderViewHost, which
   // happens before the RenderProcessHost is created. This way, the instance
   // has the correct factory and creates our special RenderProcessHosts.
   content::RenderProcessHostFactory* render_process_host_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRenderViewHostFactory);
 };
 
 // RenderViewHostTestHarness ---------------------------------------------------
 
 class RenderViewHostTestHarness : public testing::Test {
  public:
   RenderViewHostTestHarness();
   virtual ~RenderViewHostTestHarness();
 
   content::NavigationController& controller();
   virtual TestTabContents* contents();
-  TestRenderViewHost* rvh();
-  TestRenderViewHost* pending_rvh();
-  TestRenderViewHost* active_rvh();
+  content::TestRenderViewHost* rvh();
+  content::TestRenderViewHost* pending_rvh();
+  content::TestRenderViewHost* active_rvh();
   content::BrowserContext* browser_context();
   MockRenderProcessHost* process();
 
   // Frees the current tab contents for tests that want to test destruction.
   void DeleteContents();
 
   // Sets the current tab contents for tests that want to alter it. Takes
   // ownership of the TestTabContents passed.
   virtual void SetContents(TestTabContents* contents);
 
@@ skipping 27 matching lines @@
   scoped_ptr<TestTabContents> contents_;
 #if defined(USE_AURA)
   scoped_ptr<aura::RootWindow> root_window_;
   scoped_ptr<aura::test::TestStackingClient> test_stacking_client_;
 #endif
 
   DISALLOW_COPY_AND_ASSIGN(RenderViewHostTestHarness);
 };
 
 #endif  // CONTENT_BROWSER_RENDERER_HOST_TEST_RENDER_VIEW_HOST_H_