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

content/renderer/render_view_impl.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/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
-#include <string>
-#include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop_proxy.h"
@@ skipping 293 matching lines @@
 using WebKit::WebURLError;
 using WebKit::WebURLRequest;
 using WebKit::WebURLResponse;
 using WebKit::WebVector;
 using WebKit::WebView;
 using WebKit::WebWidget;
 using WebKit::WebWindowFeatures;
 using appcache::WebApplicationCacheHostImpl;
 using base::Time;
 using base::TimeDelta;
-using content::DocumentState;
-using content::NavigationState;
-using content::PasswordForm;
-using content::Referrer;
-using content::RenderThread;
-using content::RenderViewObserver;
-using content::RenderViewVisitor;
-using content::RendererAccessibilityComplete;
-using content::RendererAccessibilityFocusOnly;
-using content::V8ValueConverter;
+
 using webkit_glue::AltErrorPageResourceFetcher;
 using webkit_glue::ResourceFetcher;
 using webkit_glue::WebPreferences;
 using webkit_glue::WebURLResponseExtraDataImpl;
 
 #if defined(OS_ANDROID)
-using content::AddressDetector;
-using content::ContentDetector;
-using content::EmailDetector;
-using content::PhoneNumberDetector;
 using WebKit::WebContentDetectionResult;
 using WebKit::WebFloatPoint;
 using WebKit::WebFloatRect;
 using WebKit::WebHitTestResult;
 #endif
 
+namespace content {
+
 //-----------------------------------------------------------------------------
 
 typedef std::map<WebKit::WebView*, RenderViewImpl*> ViewMap;
 static base::LazyInstance<ViewMap> g_view_map = LAZY_INSTANCE_INITIALIZER;
 
 // Time, in seconds, we delay before sending content state changes (such as form
 // state and scroll position) to the browser. We delay sending changes to avoid
 // spamming the browser.
 // To avoid having tab/session restore require sending a message to get the
 // current content state during tab closing we use a shorter timeout for the
@@ skipping 144 matching lines @@
     NotifyTimezoneChange(child);
 }
 
 // Recursively walks the frame tree and serializes it to JSON as described in
 // the comment for ViewMsg_UpdateFrameTree.  If |exclude_frame_subtree| is not
 // NULL, the subtree for the frame is not included in the serialized form.
 // This is used when a frame is going to be removed from the tree.
 static void ConstructFrameTree(WebKit::WebFrame* frame,
                                WebKit::WebFrame* exclude_frame_subtree,
                                base::DictionaryValue* dict) {
-  dict->SetString(content::kFrameTreeNodeNameKey,
+  dict->SetString(kFrameTreeNodeNameKey,
                   UTF16ToUTF8(frame->assignedName()).c_str());
-  dict->SetInteger(content::kFrameTreeNodeIdKey, frame->identifier());
+  dict->SetInteger(kFrameTreeNodeIdKey, frame->identifier());
 
   WebFrame* child = frame->firstChild();
   ListValue* children = new ListValue();
   for (; child; child = child->nextSibling()) {
     if (child == exclude_frame_subtree)
       continue;
 
     base::DictionaryValue* d = new base::DictionaryValue();
     ConstructFrameTree(child, exclude_frame_subtree, d);
     children->Append(d);
   }
   if (children->GetSize() > 0)
-    dict->Set(content::kFrameTreeNodeSubtreeKey, children);
+    dict->Set(kFrameTreeNodeSubtreeKey, children);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 struct RenderViewImpl::PendingFileChooser {
-  PendingFileChooser(const content::FileChooserParams& p,
-                     WebFileChooserCompletion* c)
+  PendingFileChooser(const FileChooserParams& p, WebFileChooserCompletion* c)
       : params(p),
         completion(c) {
   }
-  content::FileChooserParams params;
+  FileChooserParams params;
   WebFileChooserCompletion* completion;  // MAY BE NULL to skip callback.
 };
 
 namespace {
 
 class WebWidgetLockTarget : public MouseLockDispatcher::LockTarget {
  public:
   explicit WebWidgetLockTarget(WebKit::WebWidget* webwidget)
       : webwidget_(webwidget) {}
 
@@ skipping 26 matching lines @@
     return -1;
 
   return item.httpBody().identifier();
 }
 
 }  // namespace
 
 RenderViewImpl::RenderViewImpl(
     gfx::NativeViewId parent_hwnd,
     int32 opener_id,
-    const content::RendererPreferences& renderer_prefs,
+    const RendererPreferences& renderer_prefs,
     const WebPreferences& webkit_prefs,
     SharedRenderViewCounter* counter,
     int32 routing_id,
     int32 surface_id,
     int64 session_storage_namespace_id,
     const string16& frame_name,
     bool is_renderer_created,
     bool swapped_out,
     int32 next_page_id,
     const WebKit::WebScreenInfo& screen_info,
-    content::old::GuestToEmbedderChannel* guest_to_embedder_channel,
+    old::GuestToEmbedderChannel* guest_to_embedder_channel,
     AccessibilityMode accessibility_mode)
     : RenderWidget(WebKit::WebPopupTypeNone, screen_info, swapped_out),
       webkit_preferences_(webkit_prefs),
       send_content_state_immediately_(false),
       enabled_bindings_(0),
       send_preferred_size_changes_(false),
       is_loading_(false),
       navigation_gesture_(NavigationGestureUnknown),
       opened_by_user_gesture_(true),
       opener_suppressed_(false),
@@ skipping 52 matching lines @@
 #else
   notification_provider_ = NULL;
 #endif
 
   webwidget_ = WebView::create(this);
   webwidget_mouse_lock_target_.reset(new WebWidgetLockTarget(webwidget_));
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
 
 #if defined(OS_ANDROID)
-  scoped_ptr<content::DeviceInfo> device_info(new content::DeviceInfo());
+  scoped_ptr<DeviceInfo> device_info(new DeviceInfo());
 
   webview()->setDeviceScaleFactor(device_info->GetDPIScale());
 
   const std::string region_code =
       command_line.HasSwitch(switches::kNetworkCountryIso)
           ? command_line.GetSwitchValueASCII(switches::kNetworkCountryIso)
           : device_info->GetNetworkCountryIso();
   content_detectors_.push_back(linked_ptr<ContentDetector>(
       new AddressDetector()));
   content_detectors_.push_back(linked_ptr<ContentDetector>(
@@ skipping 59 matching lines @@
   devtools_agent_ = new DevToolsAgent(this);
   mouse_lock_dispatcher_ = new RenderViewMouseLockDispatcher(this);
   intents_host_ = new WebIntentsHost(this);
 
   // Create renderer_accessibility_ if needed.
   OnSetAccessibilityMode(accessibility_mode);
 
   new IdleUserDetector(this);
 
   if (command_line.HasSwitch(switches::kDomAutomationController))
-    enabled_bindings_ |= content::BINDINGS_POLICY_DOM_AUTOMATION;
+    enabled_bindings_ |= BINDINGS_POLICY_DOM_AUTOMATION;
 
   ProcessViewLayoutFlags(command_line);
 
-  content::GetContentClient()->renderer()->RenderViewCreated(this);
+  GetContentClient()->renderer()->RenderViewCreated(this);
 
   // If we have an opener_id but we weren't created by a renderer, then
   // it's the browser asking us to set our opener to another RenderView.
   if (opener_id != MSG_ROUTING_NONE && !is_renderer_created) {
     RenderViewImpl* opener_view = FromRoutingID(opener_id);
     if (opener_view)
       webview()->mainFrame()->setOpener(opener_view->webview()->mainFrame());
   }
 
   // If we are initially swapped out, navigate to kSwappedOutURL.
@@ skipping 39 matching lines @@
 }
 
 /*static*/
 RenderViewImpl* RenderViewImpl::FromWebView(WebView* webview) {
   ViewMap* views = g_view_map.Pointer();
   ViewMap::iterator it = views->find(webview);
   return it == views->end() ? NULL : it->second;
 }
 
 /*static*/
-content::RenderView*
-    content::RenderView::FromWebView(WebKit::WebView* webview) {
+RenderView* RenderView::FromWebView(WebKit::WebView* webview) {
   return RenderViewImpl::FromWebView(webview);
 }
 
 /*static*/
-void content::RenderView::ForEach(content::RenderViewVisitor* visitor) {
+void RenderView::ForEach(RenderViewVisitor* visitor) {
   ViewMap* views = g_view_map.Pointer();
   for (ViewMap::iterator it = views->begin(); it != views->end(); ++it) {
     if (!visitor->Visit(it->second))
       return;
   }
 }
 
 /*static*/
 RenderViewImpl* RenderViewImpl::Create(
     gfx::NativeViewId parent_hwnd,
     int32 opener_id,
-    const content::RendererPreferences& renderer_prefs,
+    const RendererPreferences& renderer_prefs,
     const WebPreferences& webkit_prefs,
     SharedRenderViewCounter* counter,
     int32 routing_id,
     int32 surface_id,
     int64 session_storage_namespace_id,
     const string16& frame_name,
     bool is_renderer_created,
     bool swapped_out,
     int32 next_page_id,
     const WebKit::WebScreenInfo& screen_info,
-    content::old::GuestToEmbedderChannel* guest_to_embedder_channel,
+    old::GuestToEmbedderChannel* guest_to_embedder_channel,
     AccessibilityMode accessibility_mode) {
   DCHECK(routing_id != MSG_ROUTING_NONE);
   return new RenderViewImpl(
       parent_hwnd,
       opener_id,
       renderer_prefs,
       webkit_prefs,
       counter,
       routing_id,
       surface_id,
@@ skipping 22 matching lines @@
 
 void RenderViewImpl::SetReportLoadProgressEnabled(bool enabled) {
   if (!enabled) {
     load_progress_tracker_.reset(NULL);
     return;
   }
   if (load_progress_tracker_ == NULL)
     load_progress_tracker_.reset(new LoadProgressTracker(this));
 }
 
-content::old::GuestToEmbedderChannel*
-    RenderViewImpl::GetGuestToEmbedderChannel() const {
+old::GuestToEmbedderChannel* RenderViewImpl::GetGuestToEmbedderChannel() const {
   return guest_to_embedder_channel_;
 }
 
 void RenderViewImpl::SetGuestToEmbedderChannel(
-    content::old::GuestToEmbedderChannel* channel) {
+    old::GuestToEmbedderChannel* channel) {
   guest_to_embedder_channel_ = channel;
 }
 
 void RenderViewImpl::PluginCrashed(const FilePath& plugin_path) {
   Send(new ViewHostMsg_CrashedPlugin(routing_id_, plugin_path));
 }
 
 void RenderViewImpl::RegisterPluginDelegate(WebPluginDelegateProxy* delegate) {
   plugin_delegates_.insert(delegate);
   // If the renderer is visible, set initial visibility and focus state.
@@ skipping 33 matching lines @@
     webview()->transferActiveWheelFlingAnimation(params);
 }
 
 bool RenderViewImpl::HasIMETextFocus() {
   return GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE;
 }
 
 bool RenderViewImpl::OnMessageReceived(const IPC::Message& message) {
   WebFrame* main_frame = webview() ? webview()->mainFrame() : NULL;
   if (main_frame)
-    content::GetContentClient()->SetActiveURL(main_frame->document().url());
+    GetContentClient()->SetActiveURL(main_frame->document().url());
 
   ObserverListBase<RenderViewObserver>::Iterator it(observers_);
   RenderViewObserver* observer;
   while ((observer = it.GetNext()) != NULL)
     if (observer->OnMessageReceived(message))
       return true;
 
   bool handled = true;
   bool msg_is_ok = true;
   IPC_BEGIN_MESSAGE_MAP_EX(RenderViewImpl, message, msg_is_ok)
@@ skipping 127 matching lines @@
     CHECK(false) << "Unable to deserialize message in RenderViewImpl.";
   }
 
   return handled;
 }
 
 void RenderViewImpl::OnNavigate(const ViewMsg_Navigate_Params& params) {
   // If we don't have guest-to-embedder channel associated with this RenderView
   // but we need one, grab one now.
   if (!params.embedder_channel_name.empty() && !GetGuestToEmbedderChannel()) {
-    content::old::GuestToEmbedderChannel* embedder_channel =
+    old::GuestToEmbedderChannel* embedder_channel =
         RenderThreadImpl::current()->browser_plugin_channel_manager()->
             GetChannelByName(params.embedder_channel_name);
     DCHECK(embedder_channel);
     SetGuestToEmbedderChannel(embedder_channel);
     host_window_set_ = false;
     // TODO(fsamuel): This is test code. Need to find a better way to tell
     // a WebView to drop its context. This needs to change in
     // GuestToEmbedderChannel::OnContextLost.
     GetWebView()->loseCompositorContext(1);
     RenderThreadImpl::current()->browser_plugin_channel_manager()->
@@ skipping 24 matching lines @@
   }
 
   history_list_offset_ = params.current_history_list_offset;
   history_list_length_ = params.current_history_list_length;
   if (history_list_length_ >= 0)
     history_page_ids_.resize(history_list_length_, -1);
   if (params.pending_history_list_offset >= 0 &&
       params.pending_history_list_offset < history_list_length_)
     history_page_ids_[params.pending_history_list_offset] = params.page_id;
 
-  content::GetContentClient()->SetActiveURL(params.url);
+  GetContentClient()->SetActiveURL(params.url);
 
   WebFrame* main_frame = webview()->mainFrame();
   if (is_reload && main_frame->currentHistoryItem().isNull()) {
     // We cannot reload if we do not have any history state.  This happens, for
     // example, when recovering from a crash.  Our workaround here is a bit of
     // a hack since it means that reload after a crashed tab does not cause an
     // end-to-end cache validation.
     is_reload = false;
   }
 
@@ skipping 423 matching lines @@
         webkit_glue::CreateHistoryStateForURL(GURL(request.url()));
   }
 
   if (!frame->parent()) {
     // Top-level navigation.
 
     // Reset the zoom limits in case a plugin had changed them previously. This
     // will also call us back which will cause us to send a message to
     // update WebContentsImpl.
     webview()->zoomLimitsChanged(
-        WebView::zoomFactorToZoomLevel(content::kMinimumZoomFactor),
-        WebView::zoomFactorToZoomLevel(content::kMaximumZoomFactor));
+        WebView::zoomFactorToZoomLevel(kMinimumZoomFactor),
+        WebView::zoomFactorToZoomLevel(kMaximumZoomFactor));
 
     // Set zoom level, but don't do it for full-page plugin since they don't use
     // the same zoom settings.
     HostZoomLevels::iterator host_zoom =
         host_zoom_levels_.find(GURL(request.url()));
     if (webview()->mainFrame()->document().isPluginDocument()) {
       // Reset the zoom levels for plugins.
       webview()->setZoomLevel(false, 0);
     } else {
       if (host_zoom != host_zoom_levels_.end())
         webview()->setZoomLevel(false, host_zoom->second);
     }
 
     if (host_zoom != host_zoom_levels_.end()) {
       // This zoom level was merely recorded transiently for this load.  We can
       // erase it now.  If at some point we reload this page, the browser will
       // send us a new, up-to-date zoom level.
       host_zoom_levels_.erase(host_zoom);
     }
 
     // Update contents MIME type for main frame.
     params.contents_mime_type = ds->response().mimeType().utf8();
 
     params.transition = navigation_state->transition_type();
-    if (!content::PageTransitionIsMainFrame(params.transition)) {
+    if (!PageTransitionIsMainFrame(params.transition)) {
       // If the main frame does a load, it should not be reported as a subframe
       // navigation.  This can occur in the following case:
       // 1. You're on a site with frames.
       // 2. You do a subframe navigation.  This is stored with transition type
       //    MANUAL_SUBFRAME.
       // 3. You navigate to some non-frame site, say, google.com.
       // 4. You navigate back to the page from step 2.  Since it was initially
       //    MANUAL_SUBFRAME, it will be that same transition type here.
       // We don't want that, because any navigation that changes the toplevel
       // frame should be tracked as a toplevel navigation (this allows us to
       // update the URL bar, etc).
-      params.transition = content::PAGE_TRANSITION_LINK;
+      params.transition = PAGE_TRANSITION_LINK;
     }
 
     // If we have a valid consumed client redirect source,
     // the page contained a client redirect (meta refresh, document.loc...),
     // so we set the referrer and transition to match.
     if (completed_client_redirect_src_.url.is_valid()) {
       DCHECK(completed_client_redirect_src_.url == params.redirects[0]);
       params.referrer = completed_client_redirect_src_;
-      params.transition = static_cast<content::PageTransition>(
-          params.transition | content::PAGE_TRANSITION_CLIENT_REDIRECT);
+      params.transition = static_cast<PageTransition>(
+          params.transition | PAGE_TRANSITION_CLIENT_REDIRECT);
     } else {
       // Bug 654101: the referrer will be empty on https->http transitions. It
       // would be nice if we could get the real referrer from somewhere.
       params.referrer = Referrer(GURL(
           original_request.httpHeaderField(WebString::fromUTF8("Referer"))),
           GetReferrerPolicyFromRequest(frame, original_request));
     }
 
     string16 method = request.httpMethod();
     if (EqualsASCII(method, "POST")) {
@@ skipping 18 matching lines @@
     // these functions send a ViewHostMsg_ContentBlocked message, it arrives
     // after the ViewHostMsg_FrameNavigate message.
     Send(new ViewHostMsg_FrameNavigate(routing_id_, params));
   } else {
     // Subframe navigation: the type depends on whether this navigation
     // generated a new session history entry. When they do generate a session
     // history entry, it means the user initiated the navigation and we should
     // mark it as such. This test checks if this is the first time UpdateURL
     // has been called since WillNavigateToURL was called to initiate the load.
     if (page_id_ > last_page_id_sent_to_browser_)
-      params.transition = content::PAGE_TRANSITION_MANUAL_SUBFRAME;
+      params.transition = PAGE_TRANSITION_MANUAL_SUBFRAME;
     else
-      params.transition = content::PAGE_TRANSITION_AUTO_SUBFRAME;
+      params.transition = PAGE_TRANSITION_AUTO_SUBFRAME;
 
     Send(new ViewHostMsg_FrameNavigate(routing_id_, params));
   }
 
   last_page_id_sent_to_browser_ =
       std::max(last_page_id_sent_to_browser_, page_id_);
 
   // If we end up reusing this WebRequest (for example, due to a #ref click),
   // we don't want the transition type to persist.  Just clear it.
-  navigation_state->set_transition_type(content::PAGE_TRANSITION_LINK);
+  navigation_state->set_transition_type(PAGE_TRANSITION_LINK);
 }
 
 // Tell the embedding application that the title of the active page has changed
 void RenderViewImpl::UpdateTitle(WebFrame* frame,
                                  const string16& title,
                                  WebTextDirection title_direction) {
   // Ignore all but top level navigations.
   if (frame->parent())
     return;
 
-  string16 shortened_title = title.substr(0, content::kMaxTitleChars);
+  string16 shortened_title = title.substr(0, kMaxTitleChars);
   Send(new ViewHostMsg_UpdateTitle(routing_id_, page_id_, shortened_title,
                                    title_direction));
 }
 
 void RenderViewImpl::UpdateEncoding(WebFrame* frame,
                                     const std::string& encoding_name) {
   // Only update main frame's encoding_name.
   if (webview()->mainFrame() == frame &&
       last_encoding_name_ != encoding_name) {
     // Save the encoding name for later comparing.
@@ skipping 15 matching lines @@
 
   const WebHistoryItem& item =
       webview()->mainFrame()->previousHistoryItem();
   SendUpdateState(item);
 }
 
 void RenderViewImpl::SendUpdateState(const WebHistoryItem& item) {
   if (item.isNull())
     return;
 
-  // Don't send state updates for content::kSwappedOutURL.
-  if (item.urlString() == WebString::fromUTF8(content::kSwappedOutURL))
+  // Don't send state updates for kSwappedOutURL.
+  if (item.urlString() == WebString::fromUTF8(kSwappedOutURL))
     return;
 
   Send(new ViewHostMsg_UpdateState(
       routing_id_, page_id_, webkit_glue::HistoryItemToString(item)));
 }
 
 void RenderViewImpl::OpenURL(WebFrame* frame,
                              const GURL& url,
                              const Referrer& referrer,
                              WebNavigationPolicy policy) {
@@ skipping 12 matching lines @@
     const WebURLRequest& failed_request,
     const WebURLError& error,
     const std::string& html,
     bool replace) {
   std::string alt_html;
   const std::string* error_html;
 
   if (!html.empty()) {
     error_html = &html;
   } else {
-    content::GetContentClient()->renderer()->GetNavigationErrorStrings(
+    GetContentClient()->renderer()->GetNavigationErrorStrings(
         failed_request, error, &alt_html, NULL);
     error_html = &alt_html;
   }
 
   frame->loadHTMLString(*error_html,
-                        GURL(content::kUnreachableWebDataURL),
+                        GURL(kUnreachableWebDataURL),
                         error.unreachableURL,
                         replace);
 }
 
-bool RenderViewImpl::RunJavaScriptMessage(content::JavaScriptMessageType type,
+bool RenderViewImpl::RunJavaScriptMessage(JavaScriptMessageType type,
                                           const string16& message,
                                           const string16& default_value,
                                           const GURL& frame_url,
                                           string16* result) {
   bool success = false;
   string16 result_temp;
   if (!result)
     result = &result_temp;
 
   SendAndRunNestedMessageLoop(new ViewHostMsg_RunJavaScriptMessage(
@@ skipping 337 matching lines @@
   color_chooser->Open(static_cast<SkColor>(initial_color));
   return color_chooser;
 }
 
 bool RenderViewImpl::runFileChooser(
     const WebKit::WebFileChooserParams& params,
     WebFileChooserCompletion* chooser_completion) {
   // Do not open the file dialog in a hidden RenderView.
   if (is_hidden())
     return false;
-  content::FileChooserParams ipc_params;
+  FileChooserParams ipc_params;
   if (params.directory)
-    ipc_params.mode = content::FileChooserParams::OpenFolder;
+    ipc_params.mode = FileChooserParams::OpenFolder;
   else if (params.multiSelect)
-    ipc_params.mode = content::FileChooserParams::OpenMultiple;
+    ipc_params.mode = FileChooserParams::OpenMultiple;
   else if (params.saveAs)
-    ipc_params.mode = content::FileChooserParams::Save;
+    ipc_params.mode = FileChooserParams::Save;
   else
-    ipc_params.mode = content::FileChooserParams::Open;
+    ipc_params.mode = FileChooserParams::Open;
   ipc_params.title = params.title;
   ipc_params.default_file_name =
       webkit_glue::WebStringToFilePath(params.initialValue);
   ipc_params.accept_types.reserve(params.acceptTypes.size());
   for (size_t i = 0; i < params.acceptTypes.size(); ++i)
     ipc_params.accept_types.push_back(params.acceptTypes[i]);
 
   return ScheduleFileChooser(ipc_params, chooser_completion);
 }
 
 void RenderViewImpl::runModalAlertDialog(WebFrame* frame,
                                          const WebString& message) {
-  RunJavaScriptMessage(content::JAVASCRIPT_MESSAGE_TYPE_ALERT,
+  RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_ALERT,
                        message,
                        string16(),
                        frame->document().url(),
                        NULL);
 }
 
 bool RenderViewImpl::runModalConfirmDialog(WebFrame* frame,
                                            const WebString& message) {
-  return RunJavaScriptMessage(content::JAVASCRIPT_MESSAGE_TYPE_CONFIRM,
+  return RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_CONFIRM,
                               message,
                               string16(),
                               frame->document().url(),
                               NULL);
 }
 
 bool RenderViewImpl::runModalPromptDialog(WebFrame* frame,
                                           const WebString& message,
                                           const WebString& default_value,
                                           WebString* actual_value) {
   string16 result;
-  bool ok = RunJavaScriptMessage(content::JAVASCRIPT_MESSAGE_TYPE_PROMPT,
+  bool ok = RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_PROMPT,
                                  message,
                                  default_value,
                                  frame->document().url(),
                                  &result);
   if (ok)
     actual_value->assign(result);
   return ok;
 }
 
 bool RenderViewImpl::runModalBeforeUnloadDialog(
@@ skipping 20 matching lines @@
 }
 
 void RenderViewImpl::showContextMenu(
     WebFrame* frame, const WebContextMenuData& data) {
   // TODO(fsamuel): In the future, we might want the embedder to be able to
   // decide whether the guest can show a context menu or not. See
   // http://www.crbug.com/134207
   if (GetGuestToEmbedderChannel())
     return;
 
-  content::ContextMenuParams params(data);
+  ContextMenuParams params(data);
 
   // Plugins, e.g. PDF, don't currently update the render view when their
   // selected text changes, but the context menu params do contain the updated
   // selection. If that's the case, update the render view's state just prior
   // to showing the context menu.
   // TODO(asvitkine): http://crbug.com/152432
   if (params.selection_text != selection_text_) {
     selection_text_ = params.selection_text;
     // TODO(asvitkine): Text offset and range is not available in this case.
     selection_text_offset_ = 0;
     selection_range_ = ui::Range(0, selection_text_.length());
     Send(new ViewHostMsg_SelectionChanged(routing_id_,
                                           selection_text_,
                                           selection_text_offset_,
                                           selection_range_));
   }
 
   // frame is NULL if invoked by BlockedPlugin.
   if (frame)
     params.frame_id = frame->identifier();
 
-  // Serializing a GURL longer than content::kMaxURLChars will fail, so don't do
+  // Serializing a GURL longer than kMaxURLChars will fail, so don't do
   // it.  We replace it with an empty GURL so the appropriate items are disabled
   // in the context menu.
   // TODO(jcivelli): http://crbug.com/45160 This prevents us from saving large
   //                 data encoded images.  We should have a way to save them.
-  if (params.src_url.spec().size() > content::kMaxURLChars)
+  if (params.src_url.spec().size() > kMaxURLChars)
     params.src_url = GURL();
   context_menu_node_ = data.node;
 
 #if defined(OS_ANDROID)
   gfx::Rect start_rect;
   gfx::Rect end_rect;
   GetSelectionBounds(&start_rect, &end_rect);
   gfx::Point start_point(start_rect.x(),
                          start_rect.bottom());
   gfx::Point end_point(end_rect.right(),
@@ skipping 16 matching lines @@
 
   // Tell the browser to display a destination link.
   if (target_url_status_ == TARGET_INFLIGHT ||
       target_url_status_ == TARGET_PENDING) {
     // If we have a request in-flight, save the URL to be sent when we
     // receive an ACK to the in-flight request. We can happily overwrite
     // any existing pending sends.
     pending_target_url_ = latest_url;
     target_url_status_ = TARGET_PENDING;
   } else {
-    // URLs larger than |content::kMaxURLChars| cannot be sent through IPC -
+    // URLs larger than |kMaxURLChars| cannot be sent through IPC -
     // see |ParamTraits<GURL>|.
-    if (latest_url.possibly_invalid_spec().size() > content::kMaxURLChars)
+    if (latest_url.possibly_invalid_spec().size() > kMaxURLChars)
       latest_url = GURL();
     Send(new ViewHostMsg_UpdateTargetURL(routing_id_, page_id_, latest_url));
     target_url_ = latest_url;
     target_url_status_ = TARGET_INFLIGHT;
   }
 }
 
 void RenderViewImpl::StartNavStateSyncTimerIfNecessary() {
   int delay;
   if (send_content_state_immediately_)
@@ skipping 136 matching lines @@
 // created RenderView (i.e., as a blocked popup or as a new tab).
 //
 void RenderViewImpl::show(WebNavigationPolicy policy) {
   DCHECK(!did_show_) << "received extraneous Show call";
   DCHECK(opener_id_ != MSG_ROUTING_NONE);
 
   if (did_show_)
     return;
   did_show_ = true;
 
-  if (content::GetContentClient()->renderer()->AllowPopup(creator_url_))
+  if (GetContentClient()->renderer()->AllowPopup(creator_url_))
     opened_by_user_gesture_ = true;
 
   // Force new windows to a popup if they were not opened with a user gesture.
   if (!opened_by_user_gesture_) {
     // We exempt background tabs for compat with older versions of Chrome.
     // TODO(darin): This seems bogus.  These should have a user gesture, so
     // we probably don't need this check.
     if (policy != WebKit::WebNavigationPolicyNewBackgroundTab)
       policy = WebKit::WebNavigationPolicyNewPopup;
   }
@@ skipping 56 matching lines @@
   RenderWidget::didActivateCompositor(input_handler_identifier);
 
   ProcessAcceleratedPinchZoomFlags(*CommandLine::ForCurrentProcess());
 }
 
 // WebKit::WebFrameClient -----------------------------------------------------
 
 WebPlugin* RenderViewImpl::createPlugin(WebFrame* frame,
                                         const WebPluginParams& params) {
   WebPlugin* plugin = NULL;
-  if (content::GetContentClient()->renderer()->OverrideCreatePlugin(
+  if (GetContentClient()->renderer()->OverrideCreatePlugin(
           this, frame, params, &plugin)) {
     return plugin;
   }
 
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
-  if (UTF16ToASCII(params.mimeType) == content::kBrowserPluginMimeType) {
+  if (UTF16ToASCII(params.mimeType) == kBrowserPluginMimeType) {
     if (cmd_line->HasSwitch(switches::kEnableBrowserPluginOldImplementation)) {
       // TODO(fsamuel): Remove this once upstreaming of the new browser plugin
       // is complete.
-      return content::old::BrowserPlugin::Create(this, frame, params);
+      return old::BrowserPlugin::Create(this, frame, params);
     } else {
-      return content::BrowserPluginManager::Get()->CreateBrowserPlugin(this,
-                                                                       frame,
-                                                                       params);
+      return BrowserPluginManager::Get()->CreateBrowserPlugin(this, frame,
+                                                              params);
     }
   }
 
   webkit::WebPluginInfo info;
   std::string mime_type;
   bool found = GetPluginInfo(params.url, frame->top()->document().url(),
                              params.mimeType.utf8(), &info, &mime_type);
   if (!found)
     return NULL;
 
@@ skipping 34 matching lines @@
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, WillCreateMediaPlayer(frame, client));
 
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
 #if defined(OS_ANDROID)
   WebGraphicsContext3D* resource_context =
       GetWebView()->sharedGraphicsContext3D();
 
   GpuChannelHost* gpu_channel_host =
       RenderThreadImpl::current()->EstablishGpuChannelSync(
-          content::CAUSE_FOR_GPU_LAUNCH_VIDEODECODEACCELERATOR_INITIALIZE);
+          CAUSE_FOR_GPU_LAUNCH_VIDEODECODEACCELERATOR_INITIALIZE);
   if (!gpu_channel_host) {
     LOG(ERROR) << "Failed to establish GPU channel for media player";
     return NULL;
   }
 
   if (cmd_line->HasSwitch(switches::kMediaPlayerInRenderProcess)) {
     if (!media_bridge_manager_.get()) {
       media_bridge_manager_.reset(
           new webkit_media::MediaPlayerBridgeManagerImpl(1));
     }
     return new webkit_media::WebMediaPlayerInProcessAndroid(
         frame,
         client,
         cookieJar(frame),
         media_player_manager_.get(),
         media_bridge_manager_.get(),
-        new content::StreamTextureFactoryImpl(
+        new StreamTextureFactoryImpl(
             resource_context, gpu_channel_host, routing_id_),
         cmd_line->HasSwitch(switches::kDisableMediaHistoryLogging));
   }
   if (!media_player_proxy_) {
-    media_player_proxy_ = new content::WebMediaPlayerProxyImplAndroid(
+    media_player_proxy_ = new WebMediaPlayerProxyImplAndroid(
         this, media_player_manager_.get());
   }
   return new webkit_media::WebMediaPlayerImplAndroid(
       frame,
       client,
       media_player_manager_.get(),
       media_player_proxy_,
-      new content::StreamTextureFactoryImpl(
+      new StreamTextureFactoryImpl(
           resource_context, gpu_channel_host, routing_id_));
 #endif
 
   media::MessageLoopFactory* message_loop_factory =
       new media::MessageLoopFactory();
   media::FilterCollection* collection = new media::FilterCollection();
   RenderMediaLog* render_media_log = new RenderMediaLog();
 
   RenderAudioSourceProvider* audio_source_provider = NULL;
 
@@ skipping 14 matching lines @@
   if (!cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode))
     context3d = RenderThreadImpl::current()->GetGpuVDAContext3D();
   if (context3d) {
     scoped_refptr<base::MessageLoopProxy> factories_loop =
         RenderThreadImpl::current()->compositor_thread() ?
         RenderThreadImpl::current()->compositor_thread()->GetWebThread()
             ->message_loop()->message_loop_proxy() :
         base::MessageLoopProxy::current();
     GpuChannelHost* gpu_channel_host =
         RenderThreadImpl::current()->EstablishGpuChannelSync(
-            content::CAUSE_FOR_GPU_LAUNCH_VIDEODECODEACCELERATOR_INITIALIZE);
+            CAUSE_FOR_GPU_LAUNCH_VIDEODECODEACCELERATOR_INITIALIZE);
     collection->GetVideoDecoders()->push_back(new media::GpuVideoDecoder(
         base::Bind(&media::MessageLoopFactory::GetMessageLoop,
                    base::Unretained(message_loop_factory),
                    media::MessageLoopFactory::kDecoder),
         factories_loop,
         new RendererGpuVideoDecoderFactories(
             gpu_channel_host, factories_loop, context3d)));
   }
 
   WebMediaPlayer* media_player =
-      content::GetContentClient()->renderer()->OverrideCreateWebMediaPlayer(
+      GetContentClient()->renderer()->OverrideCreateWebMediaPlayer(
           this, frame, client, AsWeakPtr(), collection, audio_source_provider,
           audio_source_provider, message_loop_factory, media_stream_impl_,
           render_media_log);
   if (!media_player) {
 #if defined(ENABLE_WEBRTC)
     // TODO(wjia): when all patches related to WebMediaPlayerMS have been
     // landed, remove the switch. Refer to crbug.com/142988.
     if (!cmd_line->HasSwitch(switches::kDisableWebMediaPlayerMS) &&
         MediaStreamImpl::CheckMediaStream(url)) {
       EnsureMediaStreamImpl();
@@ skipping 71 matching lines @@
 }
 
 WebNavigationPolicy RenderViewImpl::decidePolicyForNavigation(
     WebFrame* frame, const WebURLRequest& request, WebNavigationType type,
     const WebNode&, WebNavigationPolicy default_policy, bool is_redirect) {
   Referrer referrer(
       GURL(request.httpHeaderField(WebString::fromUTF8("Referer"))),
       GetReferrerPolicyFromRequest(frame, request));
 
   if (is_swapped_out_) {
-    if (request.url() != GURL(content::kSwappedOutURL)) {
+    if (request.url() != GURL(kSwappedOutURL)) {
       // Targeted links may try to navigate a swapped out frame.  Allow the
       // browser process to navigate the tab instead.  Note that it is also
       // possible for non-targeted navigations (from this view) to arrive
       // here just after we are swapped out.  It's ok to send them to the
       // browser, as long as they're for the top level frame.
       // TODO(creis): Ensure this supports targeted form submissions when
       // fixing http://crbug.com/101395.
       if (frame->parent() == NULL) {
         OpenURL(frame, request.url(), referrer, default_policy);
         return WebKit::WebNavigationPolicyIgnore;  // Suppress the load here.
       }
 
       // We should otherwise ignore in-process iframe navigations, if they
       // arrive just after we are swapped out.
       return WebKit::WebNavigationPolicyIgnore;
     }
 
-    // Allow content::kSwappedOutURL to complete.
+    // Allow kSwappedOutURL to complete.
     return default_policy;
   }
 
   // Webkit is asking whether to navigate to a new URL.
   // This is fine normally, except if we're showing UI from one security
   // context and they're trying to navigate to a different context.
   const GURL& url = request.url();
 
   // A content initiated navigation may have originated from a link-click,
   // script, drag-n-drop operation, etc.
@@ skipping 69 matching lines @@
     // must be handled by the browser process so that the correct bindings and
     // data sources can be registered.
     // Similarly, navigations to view-source URLs or within ViewSource mode
     // must be handled by the browser process.
     // Lastly, access to file:// URLs from non-file:// URL pages must be
     // handled by the browser so that ordinary renderer processes don't get
     // blessed with file permissions.
     int cumulative_bindings = RenderProcess::current()->GetEnabledBindings();
     bool is_initial_navigation = page_id_ == -1;
     bool should_fork =
-        content::GetContentClient()->HasWebUIScheme(url) ||
-        (cumulative_bindings & content::BINDINGS_POLICY_WEB_UI) ||
+        GetContentClient()->HasWebUIScheme(url) ||
+        (cumulative_bindings & BINDINGS_POLICY_WEB_UI) ||
         url.SchemeIs(chrome::kViewSourceScheme) ||
         frame->isViewSourceModeEnabled();
 
     if (!should_fork && url.SchemeIs(chrome::kFileScheme)) {
       // Fork non-file to file opens.  Check the opener URL if this is the
       // initial navigation in a newly opened window.
       GURL source_url(old_url);
       if (is_initial_navigation && source_url.is_empty() && frame->opener())
         source_url = frame->opener()->top()->document().url();
       DCHECK(!source_url.is_empty());
       should_fork = !source_url.SchemeIs(chrome::kFileScheme);
     }
 
     if (!should_fork) {
       // Give the embedder a chance.
       // For now, we skip this for POST submissions.  This is because
       // http://crbug.com/101395 is more likely to cause compatibility issues
       // with hosted apps and extensions than WebUI pages.  We will remove this
       // check when cross-process POST submissions are supported.
       if (request.httpMethod() == "GET") {
-        should_fork = content::GetContentClient()->renderer()->ShouldFork(
+        should_fork = GetContentClient()->renderer()->ShouldFork(
             frame, url, is_initial_navigation, &send_referrer);
       }
     }
 
     if (should_fork) {
       OpenURL(
           frame, url, send_referrer ? referrer : Referrer(), default_policy);
       return WebKit::WebNavigationPolicyIgnore;  // Suppress the load here.
     }
   }
@@ skipping 67 matching lines @@
 }
 
 void RenderViewImpl::willSendSubmitEvent(WebKit::WebFrame* frame,
     const WebKit::WebFormElement& form) {
   // Some login forms have onSubmit handlers that put a hash of the password
   // into a hidden field and then clear the password. (Issue 28910.)
   // This method gets called before any of those handlers run, so save away
   // a copy of the password in case it gets lost.
   DocumentState* document_state =
       DocumentState::FromDataSource(frame->dataSource());
-  document_state->set_password_form_data(content::CreatePasswordForm(form));
+  document_state->set_password_form_data(CreatePasswordForm(form));
 }
 
 void RenderViewImpl::willSubmitForm(WebFrame* frame,
                                     const WebFormElement& form) {
   DocumentState* document_state =
       DocumentState::FromDataSource(frame->provisionalDataSource());
   NavigationState* navigation_state = document_state->navigation_state();
 
-  if (navigation_state->transition_type() == content::PAGE_TRANSITION_LINK)
-    navigation_state->set_transition_type(content::PAGE_TRANSITION_FORM_SUBMIT);
+  if (navigation_state->transition_type() == PAGE_TRANSITION_LINK)
+    navigation_state->set_transition_type(PAGE_TRANSITION_FORM_SUBMIT);
 
   // Save these to be processed when the ensuing navigation is committed.
   WebSearchableFormData web_searchable_form_data(form);
   document_state->set_searchable_form_url(web_searchable_form_data.url());
   document_state->set_searchable_form_encoding(
       web_searchable_form_data.encoding().utf8());
   scoped_ptr<PasswordForm> password_form_data =
-      content::CreatePasswordForm(form);
+      CreatePasswordForm(form);
 
   // In order to save the password that the user actually typed and not one
   // that may have gotten transformed by the site prior to submit, recover it
   // from the form contents already stored by |willSendSubmitEvent| into the
   // dataSource's NavigationState (as opposed to the provisionalDataSource's,
   // which is what we're storing into now.)
   if (password_form_data.get()) {
     DocumentState* old_document_state =
         DocumentState::FromDataSource(frame->dataSource());
     if (old_document_state) {
@@ skipping 239 matching lines @@
   if (is_top_most) {
     navigation_gesture_ = frame->isProcessingUserGesture() ?
         NavigationGestureUser : NavigationGestureAuto;
 
     // Make sure redirect tracking state is clear for the new load.
     completed_client_redirect_src_ = Referrer();
   } else if (frame->parent()->isLoading()) {
     // Take note of AUTO_SUBFRAME loads here, so that we can know how to
     // load an error page.  See didFailProvisionalLoad.
     document_state->navigation_state()->set_transition_type(
-        content::PAGE_TRANSITION_AUTO_SUBFRAME);
+        PAGE_TRANSITION_AUTO_SUBFRAME);
   }
 
   FOR_EACH_OBSERVER(
       RenderViewObserver, observers_, DidStartProvisionalLoad(frame));
 
   Send(new ViewHostMsg_DidStartProvisionalLoadForFrame(
        routing_id_, frame->identifier(),
        frame->parent() ? frame->parent()->identifier() : -1,
        is_top_most, GetOpenerUrl(), ds->request().url()));
 }
@@ skipping 34 matching lines @@
       RenderViewObserver, observers_, DidFailProvisionalLoad(frame, error));
 
   bool show_repost_interstitial =
       (error.reason == net::ERR_CACHE_MISS &&
        EqualsASCII(failed_request.httpMethod(), "POST"));
 
   ViewHostMsg_DidFailProvisionalLoadWithError_Params params;
   params.frame_id = frame->identifier();
   params.is_main_frame = !frame->parent();
   params.error_code = error.reason;
-  content::GetContentClient()->renderer()->GetNavigationErrorStrings(
+  GetContentClient()->renderer()->GetNavigationErrorStrings(
       failed_request,
       error,
       NULL,
       &params.error_description);
   params.url = error.unreachableURL;
   params.showing_repost_interstitial = show_repost_interstitial;
   Send(new ViewHostMsg_DidFailProvisionalLoadWithError(
       routing_id_, params));
 
   // Don't display an error page if this is simply a cancelled load.  Aside
@@ skipping 11 matching lines @@
   // 'replace' load.  This is necessary to avoid messing up session history.
   // Otherwise, we do a normal load, which simulates a 'go' navigation as far
   // as session history is concerned.
   //
   // AUTO_SUBFRAME loads should always be treated as loads that do not advance
   // the page id.
   //
   bool replace =
       navigation_state->pending_page_id() != -1 ||
       navigation_state->transition_type() ==
-          content::PAGE_TRANSITION_AUTO_SUBFRAME;
+          PAGE_TRANSITION_AUTO_SUBFRAME;
 
   // If we failed on a browser initiated request, then make sure that our error
   // page load is regarded as the same browser initiated request.
   if (!navigation_state->is_content_initiated()) {
     pending_navigation_params_.reset(new ViewMsg_Navigate_Params);
     pending_navigation_params_->page_id =
         navigation_state->pending_page_id();
     pending_navigation_params_->pending_history_list_offset =
         navigation_state->pending_history_list_offset();
     pending_navigation_params_->transition =
@@ skipping 33 matching lines @@
   }
 
   if (is_new_navigation) {
     // When we perform a new navigation, we need to update the last committed
     // session history entry with state for the page we are leaving.
     UpdateSessionHistory(frame);
 
     // We bump our Page ID to correspond with the new session history entry.
     page_id_ = next_page_id_++;
 
-    // Don't update history_page_ids_ (etc) for content::kSwappedOutURL, since
+    // Don't update history_page_ids_ (etc) for kSwappedOutURL, since
     // we don't want to forget the entry that was there, and since we will
-    // never come back to content::kSwappedOutURL.  Note that we have to call
+    // never come back to kSwappedOutURL.  Note that we have to call
     // UpdateSessionHistory and update page_id_ even in this case, so that
     // the current entry gets a state update and so that we don't send a
     // state update to the wrong entry when we swap back in.
-    if (GetLoadingUrl(frame) != GURL(content::kSwappedOutURL)) {
+    if (GetLoadingUrl(frame) != GURL(kSwappedOutURL)) {
       // Advance our offset in session history, applying the length limit.
       // There is now no forward history.
       history_list_offset_++;
-      if (history_list_offset_ >= content::kMaxSessionHistoryEntries)
-        history_list_offset_ = content::kMaxSessionHistoryEntries - 1;
+      if (history_list_offset_ >= kMaxSessionHistoryEntries)
+        history_list_offset_ = kMaxSessionHistoryEntries - 1;
       history_list_length_ = history_list_offset_ + 1;
       history_page_ids_.resize(history_list_length_, -1);
       history_page_ids_[history_list_offset_] = page_id_;
     }
   } else {
     // Inspect the navigation_state on this frame to see if the navigation
     // corresponds to a session history navigation...  Note: |frame| may or
     // may not be the toplevel frame, but for the case of capturing session
     // history, the first committed frame suffices.  We keep track of whether
     // we've seen this commit before so that only capture session history once
@@ skipping 46 matching lines @@
                                     g_view_map.Get().size());
     }
   }
 }
 
 void RenderViewImpl::didClearWindowObject(WebFrame* frame) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidClearWindowObject(frame));
 
   GURL frame_url = frame->document().url();
-  if ((enabled_bindings_ & content::BINDINGS_POLICY_WEB_UI) &&
+  if ((enabled_bindings_ & BINDINGS_POLICY_WEB_UI) &&
       (frame_url.SchemeIs(chrome::kChromeUIScheme) ||
       frame_url.SchemeIs(chrome::kDataScheme))) {
     GetWebUIBindings()->BindToJavascript(frame, "chrome");
   }
 
-  if (enabled_bindings_ & content::BINDINGS_POLICY_DOM_AUTOMATION) {
+  if (enabled_bindings_ & BINDINGS_POLICY_DOM_AUTOMATION) {
     if (!dom_automation_controller_.get())
       dom_automation_controller_.reset(new DomAutomationController());
     dom_automation_controller_->set_message_sender(
-        static_cast<content::RenderView*>(this));
+        static_cast<RenderView*>(this));
     dom_automation_controller_->set_routing_id(routing_id());
     dom_automation_controller_->BindToJavascript(frame,
                                                  "domAutomationController");
   }
 
-  content::InjectDoNotTrackBindings(frame);
+  InjectDoNotTrackBindings(frame);
 }
 
 void RenderViewImpl::didCreateDocumentElement(WebFrame* frame) {
   // Notify the browser about non-blank documents loading in the top frame.
   GURL url = frame->document().url();
   if (url.is_valid() && url.spec() != chrome::kAboutBlankURL) {
     if (frame == webview()->mainFrame())
       Send(new ViewHostMsg_DocumentAvailableInMainFrame(routing_id_));
   }
 
@@ skipping 37 matching lines @@
 
 void RenderViewImpl::didFailLoad(WebFrame* frame, const WebURLError& error) {
   WebDataSource* ds = frame->dataSource();
   DCHECK(ds);
 
 
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, DidFailLoad(frame, error));
 
   const WebURLRequest& failed_request = ds->request();
   string16 error_description;
-  content::GetContentClient()->renderer()->GetNavigationErrorStrings(
+  GetContentClient()->renderer()->GetNavigationErrorStrings(
       failed_request,
       error,
       NULL,
       &error_description);
   Send(new ViewHostMsg_DidFailLoadWithError(routing_id_,
                                             frame->identifier(),
                                             failed_request.url(),
                                             !frame->parent(),
                                             error.reason,
                                             error_description));
@@ skipping 49 matching lines @@
                                      WebURLRequest& request,
                                      const WebURLResponse& redirect_response) {
   WebFrame* top_frame = frame->top();
   if (!top_frame)
     top_frame = frame;
   WebDataSource* provisional_data_source = top_frame->provisionalDataSource();
   WebDataSource* top_data_source = top_frame->dataSource();
   WebDataSource* data_source =
       provisional_data_source ? provisional_data_source : top_data_source;
 
-  content::PageTransition transition_type = content::PAGE_TRANSITION_LINK;
+  PageTransition transition_type = PAGE_TRANSITION_LINK;
   DocumentState* document_state = DocumentState::FromDataSource(data_source);
   DCHECK(document_state);
   NavigationState* navigation_state = document_state->navigation_state();
   transition_type = navigation_state->transition_type();
 
   GURL request_url(request.url());
   GURL new_url;
-  if (content::GetContentClient()->renderer()->WillSendRequest(
+  if (GetContentClient()->renderer()->WillSendRequest(
       frame, transition_type, request_url, &new_url)) {
     request.setURL(WebURL(new_url));
   }
 
   if (document_state->is_cache_policy_override_set())
     request.setCachePolicy(document_state->cache_policy_override());
 
   WebKit::WebReferrerPolicy referrer_policy;
   if (document_state && document_state->is_referrer_policy_set()) {
     referrer_policy = document_state->referrer_policy();
@@ skipping 112 matching lines @@
       document_state->set_alt_error_page_fetcher(
           new AltErrorPageResourceFetcher(
               error_page_url, frame, original_error,
               base::Bind(&RenderViewImpl::AltErrorPageFinished,
                          base::Unretained(this))));
       return;
     }
   }
 
   std::string error_domain;
-  if (content::GetContentClient()->renderer()->HasErrorPage(
+  if (GetContentClient()->renderer()->HasErrorPage(
           http_status_code, &error_domain)) {
     WebURLError error;
     error.unreachableURL = frame->document().url();
     error.domain = WebString::fromUTF8(error_domain);
     error.reason = http_status_code;
 
     LoadNavigationErrorPage(
         frame, frame->dataSource()->request(), error, std::string(), true);
   }
 }
@@ skipping 38 matching lines @@
 }
 
 void RenderViewImpl::didExhaustMemoryAvailableForScript(WebFrame* frame) {
   Send(new ViewHostMsg_JSOutOfMemory(routing_id_));
 }
 
 void RenderViewImpl::didCreateScriptContext(WebFrame* frame,
                                             v8::Handle<v8::Context> context,
                                             int extension_group,
                                             int world_id) {
-  content::GetContentClient()->renderer()->DidCreateScriptContext(
+  GetContentClient()->renderer()->DidCreateScriptContext(
       frame, context, extension_group, world_id);
 
   intents_host_->DidCreateScriptContext(
       frame, context, extension_group, world_id);
 }
 
 void RenderViewImpl::willReleaseScriptContext(WebFrame* frame,
                                               v8::Handle<v8::Context> context,
                                               int world_id) {
-  content::GetContentClient()->renderer()->WillReleaseScriptContext(
+  GetContentClient()->renderer()->WillReleaseScriptContext(
       frame, context, world_id);
 }
 
 void RenderViewImpl::CheckPreferredSize() {
   // We don't always want to send the change messages over IPC, only if we've
   // been put in that mode by getting a |ViewMsg_EnablePreferredSizeChangedMode|
   // message.
   if (!send_preferred_size_changes_ || !webview())
     return;
 
@@ skipping 46 matching lines @@
     scoped_ptr<WebGraphicsContext3DCommandBufferImpl> context(
         new WebGraphicsContext3DCommandBufferImpl(
             surface_id(),
             url,
             RenderThreadImpl::current(),
             AsWeakPtr()));
 
     if (!context->Initialize(
             attributes,
             false /* bind generates resources */,
-            content::CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
+            CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
       return NULL;
     return context.release();
   }
 }
 
 // The browser process needs to know the shape of the tree, as well as the names
 // and ids of all frames. This allows it to properly route JavaScript messages
 // across processes and frames. The serialization format is described in the
 // comments of the ViewMsg_FrameTreeUpdated message.
 // This function sends those updates to the browser and updates the RVH
 // corresponding to this object. It must be called on any events that modify
 // the tree structure or the names of any frames.
 void RenderViewImpl::SendUpdatedFrameTree(
     WebKit::WebFrame* exclude_frame_subtree) {
   // TODO(nasko): Frame tree updates are causing issues with postMessage, as
   // described in http://crbug.com/153701. Disable them until a proper fix is
   // in place.
 }
 
 void RenderViewImpl::CreateFrameTree(WebKit::WebFrame* frame,
                                      DictionaryValue* frame_tree) {
   // TODO(nasko): Remove once http://crbug.com/153701 is fixed.
   DCHECK(false);
   NavigateToSwappedOutURL(frame);
 
   string16 name;
-  if (frame_tree->GetString(content::kFrameTreeNodeNameKey, &name) &&
-      !name.empty()) {
+  if (frame_tree->GetString(kFrameTreeNodeNameKey, &name) && !name.empty())
     frame->setName(name);
-  }
 
   int remote_id;
-  if (frame_tree->GetInteger(content::kFrameTreeNodeIdKey, &remote_id))
+  if (frame_tree->GetInteger(kFrameTreeNodeIdKey, &remote_id))
     active_frame_id_map_.insert(std::pair<int, int>(frame->identifier(),
                                                     remote_id));
 
   ListValue* children;
-  if (!frame_tree->GetList(content::kFrameTreeNodeSubtreeKey, &children))
+  if (!frame_tree->GetList(kFrameTreeNodeSubtreeKey, &children))
     return;
 
   // Create an invisible iframe tree in the swapped out page.
   base::DictionaryValue* child;
   for (size_t i = 0; i < children->GetSize(); ++i) {
     if (!children->GetDictionary(i, &child))
       continue;
     WebElement element = frame->document().createElement("iframe");
     element.setAttribute("width", "0");
     element.setAttribute("height", "0");
@@ skipping 335 matching lines @@
     const WebURL& frame_url,
     const WebCString& data,
     WebPageSerializerClient::PageSerializationStatus status) {
   Send(new ViewHostMsg_SendSerializedHtmlData(
     routing_id(),
     frame_url,
     data.data(),
     static_cast<int32>(status)));
 }
 
-// content::RenderView implementation ------------------------------------------
+// RenderView implementation ---------------------------------------------------
 
 bool RenderViewImpl::Send(IPC::Message* message) {
   return RenderWidget::Send(message);
 }
 
 int RenderViewImpl::GetRoutingID() const {
   return routing_id_;
 }
 
 int RenderViewImpl::GetPageId() const {
@@ skipping 140 matching lines @@
 }
 
 bool RenderViewImpl::GetContentStateImmediately() const {
   return send_content_state_immediately_;
 }
 
 float RenderViewImpl::GetFilteredTimePerFrame() const {
   return filtered_time_per_frame();
 }
 
-int RenderViewImpl::ShowContextMenu(content::ContextMenuClient* client,
-                                    const content::ContextMenuParams& params) {
+int RenderViewImpl::ShowContextMenu(ContextMenuClient* client,
+                                    const ContextMenuParams& params) {
   DCHECK(client);  // A null client means "internal" when we issue callbacks.
-  content::ContextMenuParams our_params(params);
+  ContextMenuParams our_params(params);
   our_params.custom_context.request_id = pending_context_menus_.Add(client);
   Send(new ViewHostMsg_ContextMenu(routing_id_, our_params));
   return our_params.custom_context.request_id;
 }
 
 void RenderViewImpl::CancelContextMenu(int request_id) {
   DCHECK(pending_context_menus_.Lookup(request_id));
   pending_context_menus_.Remove(request_id);
 }
 
@@ skipping 33 matching lines @@
     NOTIMPLEMENTED();
     return NULL;
 #endif
   }
 
   return new WebPluginDelegateProxy(mime_type, AsWeakPtr());
 }
 
 WebKit::WebPlugin* RenderViewImpl::CreatePluginReplacement(
     const FilePath& file_path) {
-  return content::GetContentClient()->renderer()->CreatePluginReplacement(
+  return GetContentClient()->renderer()->CreatePluginReplacement(
       this, file_path);
 }
 
 void RenderViewImpl::CreatedPluginWindow(gfx::PluginWindowHandle window) {
 #if defined(USE_X11)
   Send(new ViewHostMsg_CreatePluginContainer(routing_id(), window));
 #endif
 }
 
 void RenderViewImpl::WillDestroyPluginWindow(gfx::PluginWindowHandle window) {
@@ skipping 175 matching lines @@
   if (ds->hasUnreachableURL())
     return ds->unreachableURL();
 
   const WebURLRequest& request = ds->request();
   return request.url();
 }
 
 WebUIBindings* RenderViewImpl::GetWebUIBindings() {
   if (!web_ui_bindings_.get()) {
     web_ui_bindings_.reset(new WebUIBindings(
-        static_cast<content::RenderView*>(this), routing_id_));
+        static_cast<RenderView*>(this), routing_id_));
   }
   return web_ui_bindings_.get();
 }
 
 WebKit::WebPlugin* RenderViewImpl::GetWebPluginFromPluginDocument() {
   return webview()->mainFrame()->document().to<WebPluginDocument>().plugin();
 }
 
 void RenderViewImpl::OnFind(int request_id,
                             const string16& search_text,
@@ skipping 119 matching lines @@
                                          true);  // reset the tickmarks
       }
 
       // Iterate to the next frame. The frame will not necessarily scope, for
       // example if it is not visible.
       search_frame = search_frame->traverseNext(true);
     } while (search_frame != main_frame);
   }
 }
 
-void RenderViewImpl::OnStopFinding(content::StopFindAction action) {
+void RenderViewImpl::OnStopFinding(StopFindAction action) {
 #if defined(OS_ANDROID)
   // Make sure any asynchronous messages do not disrupt an ongoing synchronous
   // find request as it might lead to deadlocks. Also, these should be safe to
   // ignore since they would belong to a previous find request.
   if (synchronous_find_reply_message_.get())
     return;
 #endif
 
   StopFinding(action);
 }
 
-void RenderViewImpl::StopFinding(content::StopFindAction action) {
+void RenderViewImpl::StopFinding(StopFindAction action) {
   WebView* view = webview();
   if (!view)
     return;
 
   WebDocument doc = view->mainFrame()->document();
   if (doc.isPluginDocument() && GetWebPluginFromPluginDocument()) {
     GetWebPluginFromPluginDocument()->stopFind();
     return;
   }
 
-  bool clear_selection = action == content::STOP_FIND_ACTION_CLEAR_SELECTION;
+  bool clear_selection = action == STOP_FIND_ACTION_CLEAR_SELECTION;
   if (clear_selection)
     view->focusedFrame()->executeCommand(WebString::fromUTF8("Unselect"));
 
   WebFrame* frame = view->mainFrame();
   while (frame) {
     frame->stopFinding(clear_selection);
     frame = frame->traverseNext(false);
   }
 
-  if (action == content::STOP_FIND_ACTION_ACTIVATE_SELECTION) {
+  if (action == STOP_FIND_ACTION_ACTIVATE_SELECTION) {
     WebFrame* focused_frame = view->focusedFrame();
     if (focused_frame) {
       WebDocument doc = focused_frame->document();
       if (!doc.isNull()) {
         WebNode node = doc.focusedNode();
         if (!node.isNull())
           node.simulateClick();
       }
     }
   }
 }
 
 #if defined(OS_ANDROID)
 void RenderViewImpl::OnSynchronousFind(int request_id,
                                        const string16& search_string,
                                        const WebFindOptions& options,
                                        IPC::Message* reply_msg) {
   // It is impossible for simultaneous blocking finds to occur.
   CHECK(!synchronous_find_reply_message_.get());
   synchronous_find_reply_message_.reset(reply_msg);
 
   // Find next should be asynchronous in order to minimize blocking
   // the UI thread as much as possible.
   DCHECK(!options.findNext);
-  StopFinding(content::STOP_FIND_ACTION_KEEP_SELECTION);
+  StopFinding(STOP_FIND_ACTION_KEEP_SELECTION);
   synchronous_find_active_match_ordinal_ = -1;
 
   Find(request_id, search_string, options);
 }
 
 void RenderViewImpl::OnActivateNearestFindResult(int request_id,
                                                  float x, float y) {
   if (!webview())
       return;
 
@@ skipping 33 matching lines @@
   }
 
   gfx::RectF active_rect = main_frame->activeFindMatchRect();
   Send(new ViewHostMsg_FindMatchRects_Reply(routing_id_,
                                                rects_version,
                                                match_rects,
                                                active_rect));
 }
 #endif
 
-void RenderViewImpl::OnZoom(content::PageZoom zoom) {
+void RenderViewImpl::OnZoom(PageZoom zoom) {
   if (!webview())  // Not sure if this can happen, but no harm in being safe.
     return;
 
   webview()->hidePopups();
 
   double old_zoom_level = webview()->zoomLevel();
   double zoom_level;
-  if (zoom == content::PAGE_ZOOM_RESET) {
+  if (zoom == PAGE_ZOOM_RESET) {
     zoom_level = 0;
   } else if (static_cast<int>(old_zoom_level) == old_zoom_level) {
     // Previous zoom level is a whole number, so just increment/decrement.
     zoom_level = old_zoom_level + zoom;
   } else {
     // Either the user hit the zoom factor limit and thus the zoom level is now
     // not a whole number, or a plugin changed it to a custom value.  We want
     // to go to the next whole number so that the user can always get back to
     // 100% with the keyboard/menu.
     if ((old_zoom_level > 1 && zoom > 0) ||
         (old_zoom_level < 1 && zoom < 0)) {
       zoom_level = static_cast<int>(old_zoom_level + zoom);
     } else {
       // We're going towards 100%, so first go to the next whole number.
       zoom_level = static_cast<int>(old_zoom_level);
     }
   }
   webview()->setZoomLevel(false, zoom_level);
   zoomLevelChanged();
 }
 
-void RenderViewImpl::OnZoomFactor(content::PageZoom zoom,
-                                  int zoom_center_x, int zoom_center_y) {
+void RenderViewImpl::OnZoomFactor(PageZoom zoom, int zoom_center_x,
+                                  int zoom_center_y) {
   ZoomFactorHelper(zoom, zoom_center_x, zoom_center_y,
                    kScalingIncrementForGesture);
 }
 
-void RenderViewImpl::ZoomFactorHelper(content::PageZoom zoom,
+void RenderViewImpl::ZoomFactorHelper(PageZoom zoom,
                                       int zoom_center_x,
                                       int zoom_center_y,
                                       float scaling_increment) {
   if (!webview())  // Not sure if this can happen, but no harm in being safe.
     return;
 
   double old_page_scale_factor = webview()->pageScaleFactor();
   double page_scale_factor;
-  if (zoom == content::PAGE_ZOOM_RESET) {
+  if (zoom == PAGE_ZOOM_RESET) {
     page_scale_factor = 1.0;
   } else {
     page_scale_factor = old_page_scale_factor +
         (zoom > 0 ? scaling_increment : -scaling_increment);
   }
   if (page_scale_factor > 0) {
     webview()->setPageScaleFactor(page_scale_factor,
                                   WebPoint(zoom_center_x, zoom_center_y));
   }
 }
@@ skipping 98 matching lines @@
 
 void RenderViewImpl::OnAllowBindings(int enabled_bindings_flags) {
   enabled_bindings_ |= enabled_bindings_flags;
 
   // Keep track of the total bindings accumulated in this process.
   RenderProcess::current()->AddBindings(enabled_bindings_flags);
 }
 
 void RenderViewImpl::OnSetWebUIProperty(const std::string& name,
                                         const std::string& value) {
-  if (enabled_bindings_ & content::BINDINGS_POLICY_WEB_UI)
+  if (enabled_bindings_ & BINDINGS_POLICY_WEB_UI)
     GetWebUIBindings()->SetProperty(name, value);
   else
     NOTREACHED() << "WebUI bindings not enabled.";
 }
 
 void RenderViewImpl::OnDragTargetDragEnter(const WebDropData& drop_data,
                                            const gfx::Point& client_point,
                                            const gfx::Point& screen_point,
                                            WebDragOperationsMask ops,
                                            int key_modifiers) {
@@ skipping 55 matching lines @@
 void RenderViewImpl::OnUpdateTimezone() {
   if (webview())
     NotifyTimezoneChange(webview()->mainFrame());
 }
 
 void RenderViewImpl::OnSetAltErrorPageURL(const GURL& url) {
   alternate_error_page_url_ = url;
 }
 
 void RenderViewImpl::OnCustomContextMenuAction(
-    const content::CustomContextMenuContext& custom_context,
+    const CustomContextMenuContext& custom_context,
     unsigned action) {
   if (custom_context.request_id) {
     // External context menu request, look in our map.
-    content::ContextMenuClient* client =
+    ContextMenuClient* client =
         pending_context_menus_.Lookup(custom_context.request_id);
     if (client)
       client->OnMenuAction(custom_context.request_id, action);
   } else {
     // Internal request, forward to WebKit.
     webview()->performCustomContextMenuAction(action);
   }
 }
 
 void RenderViewImpl::OnEnumerateDirectoryResponse(
@@ skipping 66 matching lines @@
   // |didUpdateLayout| was already called).
   didUpdateLayout();
 }
 
 void RenderViewImpl::OnDisableScrollbarsForSmallWindows(
     const gfx::Size& disable_scrollbar_size_limit) {
   disable_scrollbars_size_limit_ = disable_scrollbar_size_limit;
 }
 
 void RenderViewImpl::OnSetRendererPrefs(
-    const content::RendererPreferences& renderer_prefs) {
+    const RendererPreferences& renderer_prefs) {
   double old_zoom_level = renderer_preferences_.default_zoom_level;
   renderer_preferences_ = renderer_prefs;
   UpdateFontRenderingFromRendererPrefs();
 #if defined(TOOLKIT_GTK)
   WebColorName name = WebKit::WebColorWebkitFocusRingColor;
   WebKit::setNamedColors(&name, &renderer_prefs.focus_ring_color, 1);
   WebKit::setCaretBlinkInterval(renderer_prefs.caret_blink_interval);
   ui::NativeTheme::instance()->SetScrollbarColors(
       renderer_prefs.thumb_inactive_color,
       renderer_prefs.thumb_active_color,
@@ skipping 13 matching lines @@
         renderer_prefs.active_selection_fg_color,
         renderer_prefs.inactive_selection_bg_color,
         renderer_prefs.inactive_selection_fg_color);
     webview()->themeChanged();
   }
 #endif
 
   // If the zoom level for this page matches the old zoom default, and this
   // is not a plugin, update the zoom level to match the new default.
   if (webview() && !webview()->mainFrame()->document().isPluginDocument() &&
-      content::ZoomValuesEqual(webview()->zoomLevel(), old_zoom_level)) {
+      ZoomValuesEqual(webview()->zoomLevel(), old_zoom_level)) {
     webview()->setZoomLevel(false, renderer_preferences_.default_zoom_level);
     zoomLevelChanged();
   }
 }
 
 void RenderViewImpl::OnMediaPlayerActionAt(const gfx::Point& location,
                                            const WebMediaPlayerAction& action) {
   if (webview())
     webview()->performMediaPlayerAction(action, location);
 }
@@ skipping 13 matching lines @@
   // Prepare list to storage all savable resource links.
   std::vector<GURL> resources_list;
   std::vector<GURL> referrer_urls_list;
   std::vector<WebKit::WebReferrerPolicy> referrer_policies_list;
   std::vector<GURL> frames_list;
   webkit_glue::SavableResourcesResult result(&resources_list,
                                              &referrer_urls_list,
                                              &referrer_policies_list,
                                              &frames_list);
 
-  // webkit/ doesn't know about content::Referrer.
+  // webkit/ doesn't know about Referrer.
   if (!webkit_glue::GetAllSavableResourceLinksForCurrentPage(
           webview(),
           page_url,
           &result,
-          const_cast<const char**>(content::GetSavableSchemes()))) {
+          const_cast<const char**>(GetSavableSchemes()))) {
     // If something is wrong when collecting all savable resource links,
     // send empty list to embedder(browser) to tell it failed.
     referrer_urls_list.clear();
     referrer_policies_list.clear();
     resources_list.clear();
     frames_list.clear();
   }
 
-  std::vector<content::Referrer> referrers_list;
+  std::vector<Referrer> referrers_list;
   CHECK_EQ(referrer_urls_list.size(), referrer_policies_list.size());
   for (unsigned i = 0; i < referrer_urls_list.size(); ++i) {
     referrers_list.push_back(
-        content::Referrer(referrer_urls_list[i], referrer_policies_list[i]));
+        Referrer(referrer_urls_list[i], referrer_policies_list[i]));
   }
 
   // Send result of all savable resource links to embedder.
   Send(new ViewHostMsg_SendCurrentPageAllSavableResourceLinks(routing_id(),
                                                               resources_list,
                                                               referrers_list,
                                                               frames_list));
 }
 
 void RenderViewImpl::OnGetSerializedHtmlDataForCurrentPageWithLocalLinks(
@@ skipping 55 matching lines @@
     webview()->setVisibilityState(WebKit::WebPageVisibilityStateHidden, false);
   }
 
   // Just echo back the params in the ACK.
   Send(new ViewHostMsg_SwapOut_ACK(routing_id_, params));
 }
 
 void RenderViewImpl::NavigateToSwappedOutURL(WebKit::WebFrame* frame) {
   // We use loadRequest instead of loadHTMLString because the former commits
   // synchronously.  Otherwise a new navigation can interrupt the navigation
-  // to content::kSwappedOutURL. If that happens to be to the page we had been
+  // to kSwappedOutURL. If that happens to be to the page we had been
   // showing, then WebKit will never send a commit and we'll be left spinning.
-  GURL swappedOutURL(content::kSwappedOutURL);
+  GURL swappedOutURL(kSwappedOutURL);
   WebURLRequest request(swappedOutURL);
   frame->loadRequest(request);
 }
 
 void RenderViewImpl::OnClosePage() {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_, ClosePage());
   // TODO(creis): We'd rather use webview()->Close() here, but that currently
   // sets the WebView's delegate_ to NULL, preventing any JavaScript dialogs
   // in the onunload handler from appearing.  For now, we're bypassing that and
   // calling the FrameLoader's CloseURL method directly.  This should be
@@ skipping 48 matching lines @@
   }
 
   const GURL& error_page_url = GetAlternateErrorPageURL(error.unreachableURL,
       ec == net::ERR_NAME_NOT_RESOLVED ? DNS_ERROR : CONNECTION_ERROR);
   if (!error_page_url.is_valid())
     return false;
 
   // Load an empty page first so there is an immediate response to the error,
   // and then kick off a request for the alternate error page.
   frame->loadHTMLString(std::string(),
-                        GURL(content::kUnreachableWebDataURL),
+                        GURL(kUnreachableWebDataURL),
                         error.unreachableURL,
                         replace);
 
   // Now, create a fetcher for the error page and associate it with the data
   // source we just created via the LoadHTMLString call.  That way if another
   // navigation occurs, the fetcher will get destroyed.
   DocumentState* document_state =
       DocumentState::FromDataSource(frame->provisionalDataSource());
   document_state->set_alt_error_page_fetcher(
       new AltErrorPageResourceFetcher(
@@ skipping 346 matching lines @@
   Send(new ViewHostMsg_ImeCancelComposition(routing_id()));
   const ui::Range range(ui::Range::InvalidRange());
   const std::vector<gfx::Rect> empty_bounds;
   UpdateCompositionInfo(range, empty_bounds);
 }
 
 void RenderViewImpl::PpapiPluginSelectionChanged() {
   SyncSelectionIfRequired();
 }
 
-void RenderViewImpl::PpapiPluginCreated(content::RendererPpapiHost* host) {
+void RenderViewImpl::PpapiPluginCreated(RendererPpapiHost* host) {
   FOR_EACH_OBSERVER(RenderViewObserver, observers_,
                     DidCreatePepperPlugin(host));
 }
 
 void RenderViewImpl::OnImeSetComposition(
     const string16& text,
     const std::vector<WebKit::WebCompositionUnderline>& underlines,
     int selection_start,
     int selection_end) {
   if (pepper_delegate_.IsPluginFocused()) {
@@ skipping 206 matching lines @@
 }
 
 void RenderViewImpl::AcceleratedSurfaceBuffersSwapped(
     gfx::PluginWindowHandle window, uint64 surface_handle) {
   Send(new ViewHostMsg_AcceleratedSurfaceBuffersSwapped(
       routing_id(), window, surface_handle));
 }
 #endif  // defined(OS_MACOSX)
 
 bool RenderViewImpl::ScheduleFileChooser(
-    const content::FileChooserParams& params,
+    const FileChooserParams& params,
     WebFileChooserCompletion* completion) {
   static const size_t kMaximumPendingFileChooseRequests = 4;
   if (file_chooser_completions_.size() > kMaximumPendingFileChooseRequests) {
     // This sanity check prevents too many file choose requests from getting
     // queued which could DoS the user. Getting these is most likely a
     // programming error (there are many ways to DoS the user so it's not
     // considered a "real" security check), either in JS requesting many file
     // choosers to pop up, or in a plugin.
     //
     // TODO(brettw) we might possibly want to require a user gesture to open
@@ skipping 85 matching lines @@
                                                absolute_url,
                                                title,
                                                user_gesture));
 }
 
 WebKit::WebPageVisibilityState RenderViewImpl::visibilityState() const {
   WebKit::WebPageVisibilityState current_state = is_hidden() ?
       WebKit::WebPageVisibilityStateHidden :
       WebKit::WebPageVisibilityStateVisible;
   WebKit::WebPageVisibilityState override_state = current_state;
-  if (content::GetContentClient()->renderer()->
+  if (GetContentClient()->renderer()->
           ShouldOverridePageVisibilityState(this,
                                             &override_state))
     return override_state;
   return current_state;
 }
 
 WebKit::WebUserMediaClient* RenderViewImpl::userMediaClient() {
   EnsureMediaStreamImpl();
   return media_stream_impl_;
 }
@@ skipping 99 matching lines @@
   // TODO(jcivelli): http:/b/5793321 Implement a better fix, as detailed in bug.
   if (!external_popup_menu_.get())
     return;
 
   external_popup_menu_->DidSelectItems(canceled, selected_indices);
   external_popup_menu_.reset();
 }
 #endif
 
 void RenderViewImpl::OnContextMenuClosed(
-    const content::CustomContextMenuContext& custom_context) {
+    const CustomContextMenuContext& custom_context) {
   if (custom_context.request_id) {
     // External request, should be in our map.
-    content::ContextMenuClient* client =
+    ContextMenuClient* client =
         pending_context_menus_.Lookup(custom_context.request_id);
     if (client) {
       client->OnMenuClosed(custom_context.request_id);
       pending_context_menus_.Remove(custom_context.request_id);
     }
   } else {
     // Internal request, forward to WebKit.
     context_menu_node_.reset();
   }
 }
@@ skipping 40 matching lines @@
   target_process_id_ = process_id;
   target_routing_id_ = route_id;
   CreateFrameTree(webview()->mainFrame(), frames);
 
   updating_frame_tree_ = false;
 }
 
 bool RenderViewImpl::didTapMultipleTargets(
     const WebKit::WebGestureEvent& event,
     const WebVector<WebRect>& target_rects) {
-  using content::DisambiguationPopupHelper;
   gfx::Rect finger_rect(
       event.x - event.data.tap.width / 2, event.y - event.data.tap.height / 2,
       event.data.tap.width, event.data.tap.height);
   gfx::Rect zoom_rect;
   float scale = DisambiguationPopupHelper::ComputeZoomAreaAndScaleFactor(
       finger_rect, target_rects, GetSize(), &zoom_rect);
   if (!scale)
     return false;
 
   gfx::Size canvas_size = zoom_rect.size();
@@ skipping 18 matching lines @@
                                                transport_dib->id()));
 
   return true;
 }
 
 void RenderViewImpl::OnReleaseDisambiguationPopupDIB(
     TransportDIB::Handle dib_handle) {
   TransportDIB* dib = TransportDIB::CreateWithHandle(dib_handle);
   RenderProcess::current()->ReleaseTransportDIB(dib);
 }
+
+}  // namespace content