Move a bunch of code in content\renderer to the content namespace.

content/renderer/render_view_browsertest.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/shared_memory.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "content/common/intents_messages.h"
@@ skipping 37 matching lines @@
 #include "ui/base/keycodes/keyboard_code_conversion.h"
 #include "ui/base/x/x11_util.h"
 #endif
 
 using WebKit::WebFrame;
 using WebKit::WebInputEvent;
 using WebKit::WebMouseEvent;
 using WebKit::WebString;
 using WebKit::WebTextDirection;
 using WebKit::WebURLError;
-using content::NativeWebKeyboardEvent;
+
+namespace content  {
 
 namespace {
 #if defined(USE_AURA) && defined(USE_X11)
 // Converts MockKeyboard::Modifiers to ui::EventFlags.
 int ConvertMockKeyboardModifier(MockKeyboard::Modifiers modifiers) {
   static struct ModifierMap {
     MockKeyboard::Modifiers src;
     int dst;
   } kModifierMap[] = {
     { MockKeyboard::LEFT_SHIFT, ui::EF_SHIFT_DOWN },
     { MockKeyboard::RIGHT_SHIFT, ui::EF_SHIFT_DOWN },
     { MockKeyboard::LEFT_CONTROL, ui::EF_CONTROL_DOWN },
     { MockKeyboard::RIGHT_CONTROL, ui::EF_CONTROL_DOWN },
     { MockKeyboard::LEFT_ALT,  ui::EF_ALT_DOWN },
     { MockKeyboard::RIGHT_ALT, ui::EF_ALT_DOWN },
   };
   int flags = 0;
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kModifierMap); ++i) {
     if (kModifierMap[i].src & modifiers) {
       flags |= kModifierMap[i].dst;
     }
   }
   return flags;
 }
 #endif
 
-class WebUITestWebUIControllerFactory : public content::WebUIControllerFactory {
+class WebUITestWebUIControllerFactory : public WebUIControllerFactory {
  public:
-  virtual content::WebUIController* CreateWebUIControllerForURL(
-      content::WebUI* web_ui, const GURL& url) const OVERRIDE {
+  virtual WebUIController* CreateWebUIControllerForURL(
+      WebUI* web_ui, const GURL& url) const OVERRIDE {
     return NULL;
   }
-  virtual content::WebUI::TypeID GetWebUIType(
-      content::BrowserContext* browser_context,
-      const GURL& url) const OVERRIDE {
-    return content::WebUI::kNoWebUI;
+  virtual WebUI::TypeID GetWebUIType(BrowserContext* browser_context,
+                                     const GURL& url) const OVERRIDE {
+    return WebUI::kNoWebUI;
   }
-  virtual bool UseWebUIForURL(content::BrowserContext* browser_context,
+  virtual bool UseWebUIForURL(BrowserContext* browser_context,
                               const GURL& url) const OVERRIDE {
-    return content::GetContentClient()->HasWebUIScheme(url);
+    return GetContentClient()->HasWebUIScheme(url);
   }
-  virtual bool UseWebUIBindingsForURL(content::BrowserContext* browser_context,
+  virtual bool UseWebUIBindingsForURL(BrowserContext* browser_context,
                                       const GURL& url) const OVERRIDE {
-    return content::GetContentClient()->HasWebUIScheme(url);
+    return GetContentClient()->HasWebUIScheme(url);
   }
   virtual bool IsURLAcceptableForWebUI(
-      content::BrowserContext* browser_context,
+      BrowserContext* browser_context,
       const GURL& url,
       bool data_urls_allowed) const OVERRIDE {
     return false;
   }
 };
 
-class WebUITestClient : public content::ShellContentClient {
+class WebUITestClient : public ShellContentClient {
  public:
   WebUITestClient() {
   }
 
   virtual bool HasWebUIScheme(const GURL& url) const OVERRIDE {
     return url.SchemeIs(chrome::kChromeUIScheme);
   }
 };
 
-class WebUITestBrowserClient : public content::ShellContentBrowserClient {
+class WebUITestBrowserClient : public ShellContentBrowserClient {
  public:
   WebUITestBrowserClient() {}
 
-  virtual content::WebUIControllerFactory*
-      GetWebUIControllerFactory() OVERRIDE {
+  virtual WebUIControllerFactory* GetWebUIControllerFactory() OVERRIDE {
     return &factory_;
   }
 
  private:
   WebUITestWebUIControllerFactory factory_;
 };
 
 }
 
-class RenderViewImplTest : public content::RenderViewTest {
+class RenderViewImplTest : public RenderViewTest {
  public:
   RenderViewImplTest() {
     // Attach a pseudo keyboard device to this object.
     mock_keyboard_.reset(new MockKeyboard());
   }
 
   RenderViewImpl* view() {
     return static_cast<RenderViewImpl*>(view_);
   }
 
@@ skipping 149 matching lines @@
   EXPECT_TRUE(render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID));
 }
 
 TEST_F(RenderViewImplTest, OnNavigationHttpPost) {
   ViewMsg_Navigate_Params nav_params;
 
   // An http url will trigger a resource load so cannot be used here.
   nav_params.url = GURL("data:text/html,<div>Page</div>");
   nav_params.navigation_type = ViewMsg_Navigate_Type::NORMAL;
-  nav_params.transition = content::PAGE_TRANSITION_TYPED;
+  nav_params.transition = PAGE_TRANSITION_TYPED;
   nav_params.page_id = -1;
   nav_params.is_post = true;
 
   // Set up post data.
   const unsigned char* raw_data = reinterpret_cast<const unsigned char*>(
       "post \0\ndata");
   const unsigned int length = 11;
   const std::vector<unsigned char> post_data(raw_data, raw_data + length);
   nav_params.browser_initiated_post_data = post_data;
 
@@ skipping 18 matching lines @@
   bool successful = body.elementAt(0, element);
   EXPECT_TRUE(successful);
   EXPECT_EQ(WebKit::WebHTTPBody::Element::TypeData, element.type);
   EXPECT_EQ(length, element.data.size());
   EXPECT_EQ(0, memcmp(raw_data, element.data.data(), length));
 }
 
 TEST_F(RenderViewImplTest, DecideNavigationPolicy) {
   WebUITestClient client;
   WebUITestBrowserClient browser_client;
-  content::ContentClient* old_client = content::GetContentClient();
-  content::ContentBrowserClient* old_browser_client =
-      content::GetContentClient()->browser();
+  ContentClient* old_client = GetContentClient();
+  ContentBrowserClient* old_browser_client = GetContentClient()->browser();
 
-  content::SetContentClient(&client);
-  content::GetContentClient()->set_browser_for_testing(&browser_client);
+  SetContentClient(&client);
+  GetContentClient()->set_browser_for_testing(&browser_client);
   client.set_renderer_for_testing(old_client->renderer());
 
   // Navigations to normal HTTP URLs can be handled locally.
   WebKit::WebURLRequest request(GURL("http://foo.com"));
   WebKit::WebNavigationPolicy policy = view()->decidePolicyForNavigation(
       GetMainFrame(),
       request,
       WebKit::WebNavigationTypeLinkClicked,
       WebKit::WebNode(),
       WebKit::WebNavigationPolicyCurrentTab,
@@ skipping 16 matching lines @@
   WebKit::WebURLRequest popup_request(GURL("chrome://foo"));
   policy = view()->decidePolicyForNavigation(
       GetMainFrame(),
       popup_request,
       WebKit::WebNavigationTypeLinkClicked,
       WebKit::WebNode(),
       WebKit::WebNavigationPolicyNewForegroundTab,
       false);
   EXPECT_EQ(WebKit::WebNavigationPolicyIgnore, policy);
 
-  content::GetContentClient()->set_browser_for_testing(old_browser_client);
-  content::SetContentClient(old_client);
+  GetContentClient()->set_browser_for_testing(old_browser_client);
+  SetContentClient(old_client);
 }
 
 TEST_F(RenderViewImplTest, DecideNavigationPolicyForWebUI) {
   // Enable bindings to simulate a WebUI view.
-  view()->OnAllowBindings(content::BINDINGS_POLICY_WEB_UI);
+  view()->OnAllowBindings(BINDINGS_POLICY_WEB_UI);
 
   // Navigations to normal HTTP URLs will be sent to browser process.
   WebKit::WebURLRequest request(GURL("http://foo.com"));
   WebKit::WebNavigationPolicy policy = view()->decidePolicyForNavigation(
       GetMainFrame(),
       request,
       WebKit::WebNavigationTypeLinkClicked,
       WebKit::WebNode(),
       WebKit::WebNavigationPolicyCurrentTab,
       false);
@@ skipping 79 matching lines @@
   view()->OnSwapOut(params);
   const IPC::Message* msg2 = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_SwapOut_ACK::ID);
   ASSERT_TRUE(msg2);
 
   // If we navigate back to this RenderView, ensure we don't send a state
   // update for the swapped out URL.  (http://crbug.com/72235)
   ViewMsg_Navigate_Params nav_params;
   nav_params.url = GURL("data:text/html,<div>Page B</div>");
   nav_params.navigation_type = ViewMsg_Navigate_Type::NORMAL;
-  nav_params.transition = content::PAGE_TRANSITION_TYPED;
+  nav_params.transition = PAGE_TRANSITION_TYPED;
   nav_params.current_history_list_length = 1;
   nav_params.current_history_list_offset = 0;
   nav_params.pending_history_list_offset = 1;
   nav_params.page_id = -1;
   view()->OnNavigate(nav_params);
   ProcessPendingMessages();
   const IPC::Message* msg3 = render_thread_->sink().GetUniqueMessageMatching(
       ViewHostMsg_UpdateState::ID);
   EXPECT_FALSE(msg3);
 }
@@ skipping 41 matching lines @@
   int page_id_C;
   std::string state_C;
   ViewHostMsg_UpdateState::Read(msg_C, &page_id_C, &state_C);
   EXPECT_EQ(3, page_id_C);
   EXPECT_NE(state_B, state_C);
   render_thread_->sink().ClearMessages();
 
   // Go back to C and commit, preparing for our real test.
   ViewMsg_Navigate_Params params_C;
   params_C.navigation_type = ViewMsg_Navigate_Type::NORMAL;
-  params_C.transition = content::PAGE_TRANSITION_FORWARD_BACK;
+  params_C.transition = PAGE_TRANSITION_FORWARD_BACK;
   params_C.current_history_list_length = 4;
   params_C.current_history_list_offset = 3;
   params_C.pending_history_list_offset = 2;
   params_C.page_id = 3;
   params_C.state = state_C;
   view()->OnNavigate(params_C);
   ProcessPendingMessages();
   render_thread_->sink().ClearMessages();
 
   // Go back twice quickly, such that page B does not have a chance to commit.
   // This leads to two changes to the back/forward list but only one change to
   // the RenderView's page ID.
 
   // Back to page B (page_id 2), without committing.
   ViewMsg_Navigate_Params params_B;
   params_B.navigation_type = ViewMsg_Navigate_Type::NORMAL;
-  params_B.transition = content::PAGE_TRANSITION_FORWARD_BACK;
+  params_B.transition = PAGE_TRANSITION_FORWARD_BACK;
   params_B.current_history_list_length = 4;
   params_B.current_history_list_offset = 2;
   params_B.pending_history_list_offset = 1;
   params_B.page_id = 2;
   params_B.state = state_B;
   view()->OnNavigate(params_B);
 
   // Back to page A (page_id 1) and commit.
   ViewMsg_Navigate_Params params;
   params.navigation_type = ViewMsg_Navigate_Type::NORMAL;
-  params.transition = content::PAGE_TRANSITION_FORWARD_BACK;
+  params.transition = PAGE_TRANSITION_FORWARD_BACK;
   params_B.current_history_list_length = 4;
   params_B.current_history_list_offset = 2;
   params_B.pending_history_list_offset = 0;
   params.page_id = 1;
   params.state = state_A;
   view()->OnNavigate(params);
   ProcessPendingMessages();
 
   // Now ensure that the UpdateState message we receive is consistent
   // and represents page C in both page_id and state.
@@ skipping 31 matching lines @@
   ASSERT_TRUE(msg_A);
   int page_id_A;
   std::string state_A;
   ViewHostMsg_UpdateState::Read(msg_A, &page_id_A, &state_A);
   EXPECT_EQ(1, page_id_A);
   render_thread_->sink().ClearMessages();
 
   // Back to page A (page_id 1) and commit.
   ViewMsg_Navigate_Params params_A;
   params_A.navigation_type = ViewMsg_Navigate_Type::NORMAL;
-  params_A.transition = content::PAGE_TRANSITION_FORWARD_BACK;
+  params_A.transition = PAGE_TRANSITION_FORWARD_BACK;
   params_A.current_history_list_length = 2;
   params_A.current_history_list_offset = 1;
   params_A.pending_history_list_offset = 0;
   params_A.page_id = 1;
   params_A.state = state_A;
   view()->OnNavigate(params_A);
   ProcessPendingMessages();
 
   // A new navigation commits, clearing the forward history.
   LoadHTML("<div>Page C</div>");
   EXPECT_EQ(2, view()->history_list_length_);
   EXPECT_EQ(1, view()->history_list_offset_);
   EXPECT_EQ(3, view()->history_page_ids_[1]);
 
   // The browser then sends a stale navigation to B, which should be ignored.
   ViewMsg_Navigate_Params params_B;
   params_B.navigation_type = ViewMsg_Navigate_Type::NORMAL;
-  params_B.transition = content::PAGE_TRANSITION_FORWARD_BACK;
+  params_B.transition = PAGE_TRANSITION_FORWARD_BACK;
   params_B.current_history_list_length = 2;
   params_B.current_history_list_offset = 0;
   params_B.pending_history_list_offset = 1;
   params_B.page_id = 2;
   params_B.state = state_A;  // Doesn't matter, just has to be present.
   view()->OnNavigate(params_B);
 
   // State should be unchanged.
   EXPECT_EQ(2, view()->history_list_length_);
   EXPECT_EQ(1, view()->history_list_offset_);
@@ skipping 43 matching lines @@
   std::string state_B;
   ViewHostMsg_UpdateState::Read(msg_B, &page_id_B, &state_B);
   EXPECT_EQ(2, page_id_B);
   render_thread_->sink().ClearMessages();
 
   // Suppose the browser has limited the number of NavigationEntries to 2.
   // It has now dropped the first entry, but the renderer isn't notified.
   // Ensure that going back to page B (page_id 2) at offset 0 is successful.
   ViewMsg_Navigate_Params params_B;
   params_B.navigation_type = ViewMsg_Navigate_Type::NORMAL;
-  params_B.transition = content::PAGE_TRANSITION_FORWARD_BACK;
+  params_B.transition = PAGE_TRANSITION_FORWARD_BACK;
   params_B.current_history_list_length = 2;
   params_B.current_history_list_offset = 1;
   params_B.pending_history_list_offset = 0;
   params_B.page_id = 2;
   params_B.state = state_B;
   view()->OnNavigate(params_B);
   ProcessPendingMessages();
 
   EXPECT_EQ(2, view()->history_list_length_);
   EXPECT_EQ(0, view()->history_list_offset_);
@@ skipping 964 matching lines @@
       EXPECT_EQ(0, bounds[i].width());
     } else {
       EXPECT_LT(0, bounds[i].width());
     }
   }
   view()->OnImeConfirmComposition(empty_string, ui::Range::InvalidRange());
 }
 
 TEST_F(RenderViewImplTest, ZoomLimit) {
   const double kMinZoomLevel =
-      WebKit::WebView::zoomFactorToZoomLevel(content::kMinimumZoomFactor);
+      WebKit::WebView::zoomFactorToZoomLevel(kMinimumZoomFactor);
   const double kMaxZoomLevel =
-      WebKit::WebView::zoomFactorToZoomLevel(content::kMaximumZoomFactor);
+      WebKit::WebView::zoomFactorToZoomLevel(kMaximumZoomFactor);
 
   ViewMsg_Navigate_Params params;
   params.page_id = -1;
   params.navigation_type = ViewMsg_Navigate_Type::NORMAL;
 
   // Verifies navigation to a URL with preset zoom level indeed sets the level.
   // Regression test for http://crbug.com/139559, where the level was not
   // properly set when it is out of the default zoom limits of WebView.
   params.url = GURL("data:text/html,min_zoomlimit_test");
   view()->OnSetZoomLevelForLoadingURL(params.url, kMinZoomLevel);
@@ skipping 67 matching lines @@
   EXPECT_EQ("abcdefgopqrstuvwxyz", info.value);
   EXPECT_EQ(7, info.selectionStart);
   EXPECT_EQ(7, info.selectionEnd);
   view()->OnSetEditableSelectionOffsets(4, 8);
   view()->OnExtendSelectionAndDelete(2, 5);
   info = view()->webview()->textInputInfo();
   EXPECT_EQ("abuvwxyz", info.value);
   EXPECT_EQ(2, info.selectionStart);
   EXPECT_EQ(2, info.selectionEnd);
 }
+
+}  // namespace content