Move a bunch more code into the content namespace.

content/browser/web_contents/web_contents_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/browser/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
@@ skipping 117 matching lines @@
 // - Once the onunload handler is finished, a SwapOut_ACK message is sent to
 //   the ResourceDispatcherHost, who unpauses the response.  Data is then sent
 //   to the pending RVH.
 // - The pending renderer sends a FrameNavigate message that invokes the
 //   DidNavigate method.  This replaces the current RVH with the
 //   pending RVH.
 // - The previous renderer is kept swapped out in RenderViewHostManager in case
 //   the user goes back.  The process only stays live if another tab is using
 //   it, but if so, the existing frame relationships will be maintained.
 
-using content::BrowserContext;
-using content::DevToolsAgentHost;
-using content::DevToolsAgentHostRegistry;
-using content::DevToolsManagerImpl;
-using content::DownloadItem;
-using content::DownloadManager;
-using content::DownloadUrlParameters;
-using content::GlobalRequestID;
-using content::HostZoomMap;
-using content::InterstitialPage;
-using content::LoadNotificationDetails;
-using content::NativeWebKeyboardEvent;
-using content::NavigationController;
-using content::NavigationEntry;
-using content::NavigationEntryImpl;
-using content::OpenURLParams;
-using content::RenderViewHost;
-using content::RenderViewHostDelegate;
-using content::RenderViewHostDelegateView;
-using content::RenderViewHostImpl;
-using content::RenderWidgetHost;
-using content::RenderWidgetHostImpl;
-using content::RenderWidgetHostView;
-using content::RenderWidgetHostViewPort;
-using content::ResourceDispatcherHostImpl;
-using content::SSLStatus;
-using content::SessionStorageNamespace;
-using content::SiteInstance;
-using content::UserMetricsAction;
-using content::WebContents;
-using content::WebContentsDelegate;
-using content::WebContentsObserver;
-using content::WebUI;
-using content::WebUIController;
-using content::WebUIControllerFactory;
 using webkit_glue::WebPreferences;
 
+namespace content {
 namespace {
 
 // Amount of time we wait between when a key event is received and the renderer
 // is queried for its state and pushed to the NavigationEntry.
 const int kQueryStateDelay = 5000;
 
 const int kSyncWaitDelay = 40;
 
 const char kDotGoogleDotCom[] = ".google.com";
 
 #if defined(OS_WIN)
 
 BOOL CALLBACK InvalidateWindow(HWND hwnd, LPARAM lparam) {
   // Note: erase is required to properly paint some widgets borders. This can
   // be seen with textfields.
   InvalidateRect(hwnd, NULL, TRUE);
   return TRUE;
 }
 #endif
 
 ViewMsg_Navigate_Type::Value GetNavigationType(
-    content::BrowserContext* browser_context, const NavigationEntryImpl& entry,
+    BrowserContext* browser_context, const NavigationEntryImpl& entry,
     NavigationController::ReloadType reload_type) {
   switch (reload_type) {
     case NavigationControllerImpl::RELOAD:
       return ViewMsg_Navigate_Type::RELOAD;
     case NavigationControllerImpl::RELOAD_IGNORING_CACHE:
       return ViewMsg_Navigate_Type::RELOAD_IGNORING_CACHE;
     case NavigationControllerImpl::RELOAD_ORIGINAL_REQUEST_URL:
       return ViewMsg_Navigate_Type::RELOAD_ORIGINAL_REQUEST_URL;
     case NavigationControllerImpl::NO_RELOAD:
       break;  // Fall through to rest of function.
   }
 
   // |RenderViewImpl::PopulateStateFromPendingNavigationParams| differentiates
   // between |RESTORE_WITH_POST| and |RESTORE|.
   if (entry.restore_type() ==
       NavigationEntryImpl::RESTORE_LAST_SESSION_EXITED_CLEANLY) {
     if (entry.GetHasPostData())
       return ViewMsg_Navigate_Type::RESTORE_WITH_POST;
     return ViewMsg_Navigate_Type::RESTORE;
   }
 
   return ViewMsg_Navigate_Type::NORMAL;
 }
 
 void MakeNavigateParams(const NavigationEntryImpl& entry,
                         const NavigationControllerImpl& controller,
-                        content::WebContentsDelegate* delegate,
+                        WebContentsDelegate* delegate,
                         NavigationController::ReloadType reload_type,
                         const std::string& embedder_channel_name,
                         int embedder_container_id,
                         ViewMsg_Navigate_Params* params) {
   params->page_id = entry.GetPageID();
   params->pending_history_list_offset = controller.GetIndexOfEntry(&entry);
   params->current_history_list_offset = controller.GetLastCommittedEntryIndex();
   params->current_history_list_length = controller.GetEntryCount();
   if (!entry.GetBaseURLForDataURL().is_empty()) {
     params->base_url_for_data_url = entry.GetBaseURLForDataURL();
@@ skipping 48 matching lines @@
   std::string string_value = command_line.GetSwitchValueASCII(switch_string);
   int int_value;
   if (base::StringToInt(string_value, &int_value))
     return std::max(min_value, int_value);
   else
     return min_value;
 }
 
 }  // namespace
 
-namespace content {
-
 WebContents* WebContents::Create(
     BrowserContext* browser_context,
     SiteInstance* site_instance,
     int routing_id,
     const WebContents* base_web_contents) {
   return WebContentsImpl::Create(
       browser_context, site_instance, routing_id,
       static_cast<const WebContentsImpl*>(base_web_contents));
 }
 
@@ skipping 15 matching lines @@
 
   new_contents->Init(browser_context, site_instance, routing_id,
                      static_cast<const WebContentsImpl*>(base_web_contents));
   return new_contents;
 }
 
 WebContents* WebContents::FromRenderViewHost(const RenderViewHost* rvh) {
   return rvh->GetDelegate()->GetAsWebContents();
 }
 
-}
-
 // WebContentsImpl -------------------------------------------------------------
 
 WebContentsImpl::WebContentsImpl(
-    content::BrowserContext* browser_context,
+    BrowserContext* browser_context,
     WebContentsImpl* opener)
     : delegate_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(controller_(this, browser_context)),
       render_view_host_delegate_view_(NULL),
       opener_(opener),
       ALLOW_THIS_IN_INITIALIZER_LIST(render_manager_(this, this, this)),
       is_loading_(false),
       crashed_status_(base::TERMINATION_STATUS_STILL_RUNNING),
       crashed_error_code_(0),
       waiting_for_response_(false),
       load_state_(net::LOAD_STATE_IDLE, string16()),
       upload_size_(0),
       upload_position_(0),
       displayed_insecure_content_(false),
       capturing_contents_(false),
       is_being_destroyed_(false),
       notify_disconnection_(false),
       dialog_creator_(NULL),
 #if defined(OS_WIN)
       message_box_active_(CreateEvent(NULL, TRUE, FALSE, NULL)),
 #endif
       is_showing_before_unload_dialog_(false),
       opener_web_ui_type_(WebUI::kNoWebUI),
       closed_by_user_gesture_(false),
-      minimum_zoom_percent_(
-          static_cast<int>(content::kMinimumZoomFactor * 100)),
-      maximum_zoom_percent_(
-          static_cast<int>(content::kMaximumZoomFactor * 100)),
+      minimum_zoom_percent_(static_cast<int>(kMinimumZoomFactor * 100)),
+      maximum_zoom_percent_(static_cast<int>(kMaximumZoomFactor * 100)),
       temporary_zoom_settings_(false),
       content_restrictions_(0),
       color_chooser_(NULL) {
 }
 
 WebContentsImpl::~WebContentsImpl() {
   is_being_destroyed_ = true;
 
   for (std::set<RenderWidgetHostImpl*>::iterator iter =
            created_widgets_.begin(); iter != created_widgets_.end(); ++iter) {
     (*iter)->DetachDelegate();
   }
   created_widgets_.clear();
 
   // Clear out any JavaScript state.
   if (dialog_creator_)
     dialog_creator_->ResetJavaScriptState(this);
 
   if (color_chooser_)
     color_chooser_->End();
 
   NotifyDisconnected();
 
   // Notify any observer that have a reference on this WebContents.
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-      content::Source<WebContents>(this),
-      content::NotificationService::NoDetails());
+  NotificationService::current()->Notify(
+      NOTIFICATION_WEB_CONTENTS_DESTROYED,
+      Source<WebContents>(this),
+      NotificationService::NoDetails());
 
   // TODO(brettw) this should be moved to the view.
 #if defined(OS_WIN) && !defined(USE_AURA)
   // If we still have a window handle, destroy it. GetNativeView can return
   // NULL if this contents was part of a window that closed.
   if (GetNativeView()) {
     RenderViewHost* host = GetRenderViewHost();
     if (host && host->GetView())
       RenderWidgetHostViewPort::FromRWHV(host->GetView())->WillWmDestroy();
   }
@@ skipping 52 matching lines @@
       browser_context,
       guest_site_instance,
       MSG_ROUTING_NONE,
       NULL);  // base WebContents
   WebContentsImpl* new_contents_impl =
       static_cast<WebContentsImpl*>(new_contents);
 
   // This makes |new_contents| act as a guest.
   // For more info, see comment above class BrowserPluginGuest.
   new_contents_impl->browser_plugin_guest_.reset(
-      content::BrowserPluginGuest::Create(
+      BrowserPluginGuest::Create(
           guest_instance_id,
           new_contents_impl,
           new_contents_impl->GetRenderViewHost()));
   return new_contents;
 }
 
 WebPreferences WebContentsImpl::GetWebkitPrefs(RenderViewHost* rvh,
                                                const GURL& url) {
   WebPreferences prefs;
 
@@ skipping 126 matching lines @@
   if (command_line.HasSwitch(switches::kDisableSmoothScrolling))
     prefs.enable_scroll_animator = false;
 
   prefs.visual_word_movement_enabled =
       command_line.HasSwitch(switches::kEnableVisualWordMovement);
 
   {  // Certain GPU features might have been blacklisted.
     GpuDataManagerImpl* gpu_data_manager = GpuDataManagerImpl::GetInstance();
     DCHECK(gpu_data_manager);
     uint32 blacklist_type = gpu_data_manager->GetBlacklistedFeatures();
-    if (blacklist_type & content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING)
+    if (blacklist_type & GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING)
       prefs.accelerated_compositing_enabled = false;
-    if (blacklist_type & content::GPU_FEATURE_TYPE_WEBGL)
+    if (blacklist_type & GPU_FEATURE_TYPE_WEBGL)
       prefs.experimental_webgl_enabled = false;
-    if (blacklist_type & content::GPU_FEATURE_TYPE_FLASH3D)
+    if (blacklist_type & GPU_FEATURE_TYPE_FLASH3D)
       prefs.flash_3d_enabled = false;
-    if (blacklist_type & content::GPU_FEATURE_TYPE_FLASH_STAGE3D)
+    if (blacklist_type & GPU_FEATURE_TYPE_FLASH_STAGE3D)
       prefs.flash_stage3d_enabled = false;
-    if (blacklist_type & content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS)
+    if (blacklist_type & GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS)
       prefs.accelerated_2d_canvas_enabled = false;
-    if (blacklist_type & content::GPU_FEATURE_TYPE_MULTISAMPLING)
+    if (blacklist_type & GPU_FEATURE_TYPE_MULTISAMPLING)
       prefs.gl_multisampling_enabled = false;
-    if (blacklist_type & content::GPU_FEATURE_TYPE_3D_CSS) {
+    if (blacklist_type & GPU_FEATURE_TYPE_3D_CSS) {
       prefs.accelerated_layers_enabled = false;
       prefs.accelerated_animation_enabled = false;
     }
-    if (blacklist_type & content::GPU_FEATURE_TYPE_ACCELERATED_VIDEO)
+    if (blacklist_type & GPU_FEATURE_TYPE_ACCELERATED_VIDEO)
       prefs.accelerated_video_enabled = false;
 
     // Accelerated video and animation are slower than regular when using a
     // software 3d rasterizer. 3D CSS may also be too slow to be worthwhile.
     if (gpu_data_manager->ShouldUseSoftwareRendering()) {
       prefs.accelerated_video_enabled = false;
       prefs.accelerated_animation_enabled = false;
       prefs.accelerated_layers_enabled = false;
       prefs.accelerated_plugins_enabled = false;
     }
@@ skipping 42 matching lines @@
       switches::kDisableFixedPositionCreatesStackingContext);
 
   prefs.gesture_tap_highlight_enabled = command_line.HasSwitch(
       switches::kEnableGestureTapHighlight);
 
   prefs.number_of_cpu_cores = base::SysInfo::NumberOfProcessors();
 
   prefs.apply_page_scale_factor_in_compositor =
       command_line.HasSwitch(cc::switches::kEnablePinchInCompositor);
 
-  content::GetContentClient()->browser()->OverrideWebkitPrefs(rvh, url, &prefs);
+  GetContentClient()->browser()->OverrideWebkitPrefs(rvh, url, &prefs);
 
   // Disable compositing in guests until we have compositing path implemented
   // for guests.
   if (rvh->GetProcess()->IsGuest()) {
     prefs.force_compositing_mode = false;
     prefs.accelerated_compositing_enabled = false;
   }
 
   return prefs;
 }
@@ skipping 60 matching lines @@
     IPC_MESSAGE_HANDLER(ViewHostMsg_WebUISend, OnWebUISend)
     IPC_MESSAGE_HANDLER(ViewHostMsg_RequestPpapiBrokerPermission,
                         OnRequestPpapiBrokerPermission)
     IPC_MESSAGE_HANDLER(BrowserPluginHostMsg_CreateGuest,
                         OnBrowserPluginCreateGuest)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   message_source_ = NULL;
 
   if (!message_is_ok) {
-    content::RecordAction(UserMetricsAction("BadMessageTerminate_RVD"));
+    RecordAction(UserMetricsAction("BadMessageTerminate_RVD"));
     GetRenderProcessHost()->ReceivedBadMessage();
   }
 
   return handled;
 }
 
 void WebContentsImpl::RunFileChooser(
     RenderViewHost* render_view_host,
-    const content::FileChooserParams& params) {
+    const FileChooserParams& params) {
   if (delegate_)
     delegate_->RunFileChooser(this, params);
 }
 
 NavigationControllerImpl& WebContentsImpl::GetController() {
   return controller_;
 }
 
 const NavigationControllerImpl& WebContentsImpl::GetController() const {
   return controller_;
 }
 
-content::BrowserContext* WebContentsImpl::GetBrowserContext() const {
+BrowserContext* WebContentsImpl::GetBrowserContext() const {
   return controller_.GetBrowserContext();
 }
 
 const GURL& WebContentsImpl::GetURL() const {
   // We may not have a navigation entry yet
   NavigationEntry* entry = controller_.GetActiveEntry();
   return entry ? entry->GetVirtualURL() : GURL::EmptyGURL();
 }
 
-content::WebContentsDelegate* WebContentsImpl::GetDelegate() {
+WebContentsDelegate* WebContentsImpl::GetDelegate() {
   return delegate_;
 }
 
-void WebContentsImpl::SetDelegate(content::WebContentsDelegate* delegate) {
+void WebContentsImpl::SetDelegate(WebContentsDelegate* delegate) {
   // TODO(cbentzel): remove this debugging code?
   if (delegate == delegate_)
     return;
   if (delegate_)
     delegate_->Detach(this);
   delegate_ = delegate;
   if (delegate_)
     delegate_->Attach(this);
 }
 
-content::RenderProcessHost* WebContentsImpl::GetRenderProcessHost() const {
+RenderProcessHost* WebContentsImpl::GetRenderProcessHost() const {
   RenderViewHostImpl* host = render_manager_.current_host();
   return host ? host->GetProcess() : NULL;
 }
 
 RenderViewHost* WebContentsImpl::GetRenderViewHost() const {
   return render_manager_.current_host();
 }
 
 int WebContentsImpl::GetRoutingID() const {
   if (!GetRenderViewHost())
     return MSG_ROUTING_NONE;
 
   return GetRenderViewHost()->GetRoutingID();
 }
 
 RenderWidgetHostView* WebContentsImpl::GetRenderWidgetHostView() const {
   return render_manager_.GetRenderWidgetHostView();
 }
 
-content::WebContentsView* WebContentsImpl::GetView() const {
+WebContentsView* WebContentsImpl::GetView() const {
   return view_.get();
 }
 
-content::WebUI* WebContentsImpl::CreateWebUI(const GURL& url) {
+WebUI* WebContentsImpl::CreateWebUI(const GURL& url) {
   WebUIControllerFactory* factory =
-      content::GetContentClient()->browser()->GetWebUIControllerFactory();
+      GetContentClient()->browser()->GetWebUIControllerFactory();
   if (!factory)
     return NULL;
   WebUIImpl* web_ui = new WebUIImpl(this);
   WebUIController* controller =
       factory->CreateWebUIControllerForURL(web_ui, url);
   if (controller) {
     web_ui->SetController(controller);
     return web_ui;
   }
 
   delete web_ui;
   return NULL;
 }
 
-content::WebUI* WebContentsImpl::GetWebUI() const {
+WebUI* WebContentsImpl::GetWebUI() const {
   return render_manager_.web_ui() ? render_manager_.web_ui()
       : render_manager_.pending_web_ui();
 }
 
-content::WebUI* WebContentsImpl::GetCommittedWebUI() const {
+WebUI* WebContentsImpl::GetCommittedWebUI() const {
   return render_manager_.web_ui();
 }
 
 void WebContentsImpl::SetUserAgentOverride(const std::string& override) {
   if (GetUserAgentOverride() == override)
     return;
 
   renderer_preferences_.user_agent_override = override;
 
   // Send the new override string to the renderer.
@@ skipping 13 matching lines @@
 
 const std::string& WebContentsImpl::GetUserAgentOverride() const {
   return renderer_preferences_.user_agent_override;
 }
 
 const string16& WebContentsImpl::GetTitle() const {
   // Transient entries take precedence. They are used for interstitial pages
   // that are shown on top of existing pages.
   NavigationEntry* entry = controller_.GetTransientEntry();
   std::string accept_languages =
-      content::GetContentClient()->browser()->GetAcceptLangs(
+      GetContentClient()->browser()->GetAcceptLangs(
           GetBrowserContext());
   if (entry) {
     return entry->GetTitleForDisplay(accept_languages);
   }
   WebUI* our_web_ui = render_manager_.pending_web_ui() ?
       render_manager_.pending_web_ui() : render_manager_.web_ui();
   if (our_web_ui) {
     // Don't override the title in view source mode.
     entry = controller_.GetActiveEntry();
     if (!(entry && entry->IsViewSourceMode())) {
@@ skipping 97 matching lines @@
           crashed_status_ == base::TERMINATION_STATUS_PROCESS_WAS_KILLED);
 }
 
 void WebContentsImpl::SetIsCrashed(base::TerminationStatus status,
                                    int error_code) {
   if (status == crashed_status_)
     return;
 
   crashed_status_ = status;
   crashed_error_code_ = error_code;
-  NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TAB);
+  NotifyNavigationStateChanged(INVALIDATE_TYPE_TAB);
 }
 
 base::TerminationStatus WebContentsImpl::GetCrashedStatus() const {
   return crashed_status_;
 }
 
 bool WebContentsImpl::IsBeingDestroyed() const {
   return is_being_destroyed_;
 }
 
@@ skipping 23 matching lines @@
 
   // The resize rect might have changed while this was inactive -- send the new
   // one to make sure it's up to date.
   RenderViewHostImpl* rvh =
       static_cast<RenderViewHostImpl*>(GetRenderViewHost());
   if (rvh) {
     rvh->ResizeRectChanged(GetRootWindowResizerRect());
   }
 
   bool is_visible = true;
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED,
-      content::Source<WebContents>(this),
-      content::Details<bool>(&is_visible));
+  NotificationService::current()->Notify(
+      NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED,
+      Source<WebContents>(this),
+      Details<bool>(&is_visible));
 }
 
 void WebContentsImpl::WasHidden() {
   if (!capturing_contents_) {
     // |GetRenderViewHost()| can be NULL if the user middle clicks a link to
     // open a tab in then background, then closes the tab before selecting it.
     // This is because closing the tab calls WebContentsImpl::Destroy(), which
     // removes the |GetRenderViewHost()|; then when we actually destroy the
     // window, OnWindowPosChanged() notices and calls WasHidden() (which
     // calls us).
     RenderWidgetHostViewPort* rwhv =
         RenderWidgetHostViewPort::FromRWHV(GetRenderWidgetHostView());
     if (rwhv)
       rwhv->WasHidden();
   }
 
   bool is_visible = false;
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED,
-      content::Source<WebContents>(this),
-      content::Details<bool>(&is_visible));
+  NotificationService::current()->Notify(
+      NOTIFICATION_WEB_CONTENTS_VISIBILITY_CHANGED,
+      Source<WebContents>(this),
+      Details<bool>(&is_visible));
 }
 
 bool WebContentsImpl::NeedToFireBeforeUnload() {
   // TODO(creis): Should we fire even for interstitial pages?
   return WillNotifyDisconnection() &&
       !ShowingInterstitialPage() &&
       !static_cast<RenderViewHostImpl*>(
           GetRenderViewHost())->SuddenTerminationAllowed();
 }
 
@@ skipping 26 matching lines @@
 
 void WebContentsImpl::GetContainerBounds(gfx::Rect* out) const {
   view_->GetContainerBounds(out);
 }
 
 void WebContentsImpl::Focus() {
   view_->Focus();
 }
 
 void WebContentsImpl::Observe(int type,
-                              const content::NotificationSource& source,
-                              const content::NotificationDetails& details) {
+                              const NotificationSource& source,
+                              const NotificationDetails& details) {
   switch (type) {
-    case content::NOTIFICATION_WEB_CONTENTS_DESTROYED:
-      OnWebContentsDestroyed(
-          content::Source<content::WebContents>(source).ptr());
+    case NOTIFICATION_WEB_CONTENTS_DESTROYED:
+      OnWebContentsDestroyed(Source<WebContents>(source).ptr());
       break;
-    case content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
-      RenderWidgetHost* host = content::Source<RenderWidgetHost>(source).ptr();
+    case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED: {
+      RenderWidgetHost* host = Source<RenderWidgetHost>(source).ptr();
       for (PendingWidgetViews::iterator i = pending_widget_views_.begin();
            i != pending_widget_views_.end(); ++i) {
         if (host->GetView() == i->second) {
           pending_widget_views_.erase(i);
           break;
         }
       }
       break;
     }
     default:
       NOTREACHED();
   }
 }
 
 void WebContentsImpl::Init(BrowserContext* browser_context,
                            SiteInstance* site_instance,
                            int routing_id,
                            const WebContents* base_web_contents) {
   render_manager_.Init(browser_context, site_instance, routing_id);
 
-  view_.reset(content::GetContentClient()->browser()->
+  view_.reset(GetContentClient()->browser()->
       OverrideCreateWebContentsView(this, &render_view_host_delegate_view_));
   if (view_.get()) {
     CHECK(render_view_host_delegate_view_);
   } else {
-    content::WebContentsViewDelegate* delegate =
-        content::GetContentClient()->browser()->GetWebContentsViewDelegate(
+    WebContentsViewDelegate* delegate =
+        GetContentClient()->browser()->GetWebContentsViewDelegate(
             this);
     view_.reset(CreateWebContentsView(
         this, delegate, &render_view_host_delegate_view_));
     CHECK(render_view_host_delegate_view_);
   }
   CHECK(view_.get());
 
   // We have the initial size of the view be based on the size of the view of
   // the passed in WebContents.
   view_->CreateView(base_web_contents ?
       base_web_contents->GetView()->GetContainerSize() : gfx::Size());
 
   // Listen for whether our opener gets destroyed.
   if (opener_) {
-    registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                   content::Source<WebContents>(opener_));
+    registrar_.Add(this, NOTIFICATION_WEB_CONTENTS_DESTROYED,
+                   Source<WebContents>(opener_));
   }
 
   registrar_.Add(this,
-                 content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
-                 content::NotificationService::AllBrowserContextsAndSources());
+                 NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
+                 NotificationService::AllBrowserContextsAndSources());
 #if defined(ENABLE_JAVA_BRIDGE)
   java_bridge_dispatcher_host_manager_.reset(
       new JavaBridgeDispatcherHostManager(this));
 #endif
 
-  old_browser_plugin_host_.reset(new content::old::BrowserPluginHost(this));
+  old_browser_plugin_host_.reset(new old::BrowserPluginHost(this));
 }
 
 void WebContentsImpl::OnWebContentsDestroyed(WebContents* web_contents) {
   // Clear the opener if it has been closed.
   if (web_contents == opener_) {
-    registrar_.Remove(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                      content::Source<WebContents>(opener_));
+    registrar_.Remove(this, NOTIFICATION_WEB_CONTENTS_DESTROYED,
+                      Source<WebContents>(opener_));
     opener_ = NULL;
   }
 }
 
 void WebContentsImpl::AddObserver(WebContentsObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WebContentsImpl::RemoveObserver(WebContentsObserver* observer) {
   observers_.RemoveObserver(observer);
@@ skipping 110 matching lines @@
   // Create the new web contents. This will automatically create the new
   // WebContentsView. In the future, we may want to create the view separately.
   WebContentsImpl* new_contents =
       new WebContentsImpl(GetBrowserContext(),
                           params.opener_suppressed ? NULL : this);
 
   // We must assign the SessionStorageNamespace before calling Init().
   //
   // http://crbug.com/142685
   const std::string& partition_id =
-      content::GetContentClient()->browser()->
+      GetContentClient()->browser()->
           GetStoragePartitionIdForSite(GetBrowserContext(),
                                        site_instance->GetSiteURL());
-  content::StoragePartition* partition =
+  StoragePartition* partition =
       BrowserContext::GetStoragePartition(GetBrowserContext(),
                                           site_instance);
   DOMStorageContextImpl* dom_storage_context =
       static_cast<DOMStorageContextImpl*>(partition->GetDOMStorageContext());
   SessionStorageNamespaceImpl* session_storage_namespace_impl =
       static_cast<SessionStorageNamespaceImpl*>(session_storage_namespace);
   CHECK(session_storage_namespace_impl->IsFromContext(dom_storage_context));
   new_contents->GetController().SetSessionStorageNamespace(
       partition_id,
       session_storage_namespace);
   new_contents->Init(GetBrowserContext(), site_instance, route_id, this);
 
   new_contents->set_opener_web_ui_type(GetWebUITypeForCurrentState());
 
   if (!params.opener_suppressed) {
-    content::WebContentsView* new_view = new_contents->GetView();
+    WebContentsView* new_view = new_contents->GetView();
 
     // TODO(brettw): It seems bogus that we have to call this function on the
     // newly created object and give it one of its own member variables.
     new_view->CreateViewForWidget(new_contents->GetRenderViewHost());
 
     // Save the created window associated with the route so we can show it
     // later.
     DCHECK_NE(MSG_ROUTING_NONE, route_id);
     pending_contents_[route_id] = new_contents;
   }
 
   if (delegate_) {
     delegate_->WebContentsCreated(
         this, params.opener_frame_id, params.target_url, new_contents);
   }
 
   if (params.opener_suppressed) {
     // When the opener is suppressed, the original renderer cannot access the
     // new window.  As a result, we need to show and navigate the window here.
     bool was_blocked = false;
     if (delegate_) {
       gfx::Rect initial_pos;
       delegate_->AddNewContents(
           this, new_contents, params.disposition, initial_pos,
           params.user_gesture, &was_blocked);
     }
     if (!was_blocked) {
-      content::OpenURLParams open_params(params.target_url,
-                                         content::Referrer(),
-                                         CURRENT_TAB,
-                                         content::PAGE_TRANSITION_LINK,
-                                         true /* is_renderer_initiated */);
+      OpenURLParams open_params(params.target_url,
+                                Referrer(),
+                                CURRENT_TAB,
+                                PAGE_TRANSITION_LINK,
+                                true /* is_renderer_initiated */);
       new_contents->OpenURL(open_params);
     }
   }
 }
 
 void WebContentsImpl::CreateNewWidget(int route_id,
                                       WebKit::WebPopupType popup_type) {
   CreateNewWidget(route_id, false, popup_type);
 }
 
 void WebContentsImpl::CreateNewFullscreenWidget(int route_id) {
   CreateNewWidget(route_id, true, WebKit::WebPopupTypeNone);
 }
 
 void WebContentsImpl::CreateNewWidget(int route_id,
                                       bool is_fullscreen,
                                       WebKit::WebPopupType popup_type) {
-  content::RenderProcessHost* process = GetRenderProcessHost();
+  RenderProcessHost* process = GetRenderProcessHost();
   RenderWidgetHostImpl* widget_host =
       new RenderWidgetHostImpl(this, process, route_id);
   created_widgets_.insert(widget_host);
 
   RenderWidgetHostViewPort* widget_view =
       RenderWidgetHostViewPort::CreateViewForWidget(widget_host);
   if (!is_fullscreen) {
     // Popups should not get activated.
     widget_view->SetPopupType(popup_type);
   }
@@ skipping 95 matching lines @@
   RenderWidgetHost* widget_host = widget_host_view->GetRenderWidgetHost();
   if (!widget_host->GetProcess()->HasConnection()) {
     // The view has gone away or the renderer crashed. Nothing to do.
     return NULL;
   }
 
   return widget_host_view;
 }
 
 void WebContentsImpl::ShowContextMenu(
-    const content::ContextMenuParams& params,
-    content::ContextMenuSourceType type) {
+    const ContextMenuParams& params,
+    ContextMenuSourceType type) {
   // Allow WebContentsDelegates to handle the context menu operation first.
   if (delegate_ && delegate_->HandleContextMenu(params))
     return;
 
   render_view_host_delegate_view_->ShowContextMenu(params, type);
 }
 
 void WebContentsImpl::RequestMediaAccessPermission(
-    const content::MediaStreamRequest* request,
-    const content::MediaResponseCallback& callback) {
+    const MediaStreamRequest* request,
+    const MediaResponseCallback& callback) {
   if (delegate_)
     delegate_->RequestMediaAccessPermission(this, request, callback);
   else
-    callback.Run(content::MediaStreamDevices());
+    callback.Run(MediaStreamDevices());
 }
 
 #if defined(OS_ANDROID)
 void WebContentsImpl::AttachLayer(WebKit::WebLayer* layer) {
   if (delegate_)
     delegate_->AttachLayer(this, layer);
 }
 
 void WebContentsImpl::RemoveLayer(WebKit::WebLayer* layer) {
   if (delegate_)
@@ skipping 34 matching lines @@
 }
 
 bool WebContentsImpl::NavigateToPendingEntry(
     NavigationController::ReloadType reload_type) {
   return NavigateToEntry(
       *NavigationEntryImpl::FromNavigationEntry(controller_.GetPendingEntry()),
       reload_type);
 }
 
 void WebContentsImpl::RenderViewForInterstitialPageCreated(
-    content::RenderViewHost* render_view_host) {
+    RenderViewHost* render_view_host) {
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     RenderViewForInterstitialPageCreated(render_view_host));
 }
 
 bool WebContentsImpl::NavigateToEntry(
     const NavigationEntryImpl& entry,
     NavigationController::ReloadType reload_type) {
   // The renderer will reject IPC messages with URLs longer than
   // this limit, so don't attempt to navigate with a longer URL.
-  if (entry.GetURL().spec().size() > content::kMaxURLChars)
+  if (entry.GetURL().spec().size() > kMaxURLChars)
     return false;
 
   RenderViewHostImpl* dest_render_view_host =
       static_cast<RenderViewHostImpl*>(render_manager_.Navigate(entry));
   if (!dest_render_view_host)
     return false;  // Unable to create the desired render view host.
 
   // For security, we should never send non-Web-UI URLs to a Web UI renderer.
   // Double check that here.
   int enabled_bindings = dest_render_view_host->GetEnabledBindings();
   WebUIControllerFactory* factory =
-      content::GetContentClient()->browser()->GetWebUIControllerFactory();
+      GetContentClient()->browser()->GetWebUIControllerFactory();
   bool data_urls_allowed = delegate_ && delegate_->CanLoadDataURLsInWebUI();
   bool is_allowed_in_web_ui_renderer =
       factory &&
       factory->IsURLAcceptableForWebUI(GetBrowserContext(), entry.GetURL(),
                                        data_urls_allowed);
-  if ((enabled_bindings & content::BINDINGS_POLICY_WEB_UI) &&
+  if ((enabled_bindings & BINDINGS_POLICY_WEB_UI) &&
       !is_allowed_in_web_ui_renderer) {
     // Log the URL to help us diagnose any future failures of this CHECK.
-    content::GetContentClient()->SetActiveURL(entry.GetURL());
+    GetContentClient()->SetActiveURL(entry.GetURL());
     CHECK(0);
   }
 
   // Tell DevTools agent that it is attached prior to the navigation.
   DevToolsManagerImpl::GetInstance()->OnNavigatingToPendingEntry(
       GetRenderViewHost(),
       dest_render_view_host,
       entry.GetURL());
 
   // Notify observers that we will navigate in this RV.
@@ skipping 87 matching lines @@
          contents_mime_type_ == "text/plain" ||
          contents_mime_type_ == "text/css" ||
          net::IsSupportedJavascriptMimeType(contents_mime_type_.c_str());
 }
 
 void WebContentsImpl::OnSavePage() {
   // If we can not save the page, try to download it.
   if (!IsSavable()) {
     download_stats::RecordDownloadSource(
         download_stats::INITIATED_BY_SAVE_PACKAGE_ON_NON_HTML);
-    SaveURL(GetURL(), content::Referrer(), true);
+    SaveURL(GetURL(), Referrer(), true);
     return;
   }
 
   Stop();
 
   // Create the save package and possibly prompt the user for the name to save
   // the page as. The user prompt is an asynchronous operation that runs on
   // another thread.
   save_package_ = new SavePackage(this);
   save_package_->GetSaveInfo();
 }
 
 // Used in automated testing to bypass prompting the user for file names.
 // Instead, the names and paths are hard coded rather than running them through
 // file name sanitation and extension / mime checking.
 bool WebContentsImpl::SavePage(const FilePath& main_file,
                                const FilePath& dir_path,
-                               content::SavePageType save_type) {
+                               SavePageType save_type) {
   // Stop the page from navigating.
   Stop();
 
   save_package_ = new SavePackage(this, save_type, main_file, dir_path);
-  return save_package_->Init(content::SavePackageDownloadCreatedCallback());
+  return save_package_->Init(SavePackageDownloadCreatedCallback());
 }
 
 void WebContentsImpl::GenerateMHTML(
     const FilePath& file,
     const base::Callback<void(const FilePath&, int64)>& callback) {
   MHTMLGenerationManager::GetInstance()->GenerateMHTML(this, file, callback);
 }
 
 bool WebContentsImpl::IsActiveEntry(int32 page_id) {
   NavigationEntryImpl* active_entry =
@@ skipping 14 matching lines @@
 void WebContentsImpl::SetOverrideEncoding(const std::string& encoding) {
   SetEncoding(encoding);
   Send(new ViewMsg_SetPageEncoding(GetRoutingID(), encoding));
 }
 
 void WebContentsImpl::ResetOverrideEncoding() {
   encoding_.clear();
   Send(new ViewMsg_ResetPageEncodingToDefault(GetRoutingID()));
 }
 
-content::RendererPreferences* WebContentsImpl::GetMutableRendererPrefs() {
+RendererPreferences* WebContentsImpl::GetMutableRendererPrefs() {
   return &renderer_preferences_;
 }
 
 void WebContentsImpl::SetNewTabStartTime(const base::TimeTicks& time) {
   new_tab_start_time_ = time;
 }
 
 base::TimeTicks WebContentsImpl::GetNewTabStartTime() const {
   return new_tab_start_time_;
 }
@@ skipping 101 matching lines @@
 gfx::Size WebContentsImpl::GetPreferredSize() const {
   return preferred_size_;
 }
 
 int WebContentsImpl::GetContentRestrictions() const {
   return content_restrictions_;
 }
 
 WebUI::TypeID WebContentsImpl::GetWebUITypeForCurrentState() {
   WebUIControllerFactory* factory =
-      content::GetContentClient()->browser()->GetWebUIControllerFactory();
+      GetContentClient()->browser()->GetWebUIControllerFactory();
   if (!factory)
     return WebUI::kNoWebUI;
   return factory->GetWebUIType(GetBrowserContext(), GetURL());
 }
 
-content::WebUI* WebContentsImpl::GetWebUIForCurrentState() {
+WebUI* WebContentsImpl::GetWebUIForCurrentState() {
   // When there is a pending navigation entry, we want to use the pending WebUI
   // that goes along with it to control the basic flags. For example, we want to
   // show the pending URL in the URL bar, so we want the display_url flag to
   // be from the pending entry.
   //
   // The confusion comes because there are multiple possibilities for the
   // initial load in a tab as a side effect of the way the RenderViewHostManager
   // works.
   //
   //  - For the very first tab the load looks "normal". The new tab Web UI is
@@ skipping 42 matching lines @@
 }
 
 void WebContentsImpl::DidEndColorChooser(int color_chooser_id) {
   Send(new ViewMsg_DidEndColorChooser(GetRoutingID(), color_chooser_id));
   if (delegate_)
     delegate_->DidEndColorChooser();
   color_chooser_ = NULL;
 }
 
 bool WebContentsImpl::FocusLocationBarByDefault() {
-  content::WebUI* web_ui = GetWebUIForCurrentState();
+  WebUI* web_ui = GetWebUIForCurrentState();
   if (web_ui)
     return web_ui->ShouldFocusLocationBarByDefault();
   NavigationEntry* entry = controller_.GetActiveEntry();
   return (entry && entry->GetURL() == GURL(chrome::kAboutBlankURL));
 }
 
 void WebContentsImpl::SetFocusToLocationBar(bool select_all) {
   if (delegate_)
     delegate_->SetFocusToLocationBar(select_all);
 }
@@ skipping 10 matching lines @@
     int intent_id) {
   if (!delegate_)
     return;
 
   WebIntentsDispatcherImpl* intents_dispatcher =
       new WebIntentsDispatcherImpl(this, intent, intent_id);
   delegate_->WebIntentDispatch(this, intents_dispatcher);
 }
 
 void WebContentsImpl::DidStartProvisionalLoadForFrame(
-    content::RenderViewHost* render_view_host,
+    RenderViewHost* render_view_host,
     int64 frame_id,
     int64 parent_frame_id,
     bool is_main_frame,
     const GURL& opener_url,
     const GURL& url) {
-  bool is_error_page = (url.spec() == content::kUnreachableWebDataURL);
+  bool is_error_page = (url.spec() == kUnreachableWebDataURL);
   GURL validated_url(url);
   GURL validated_opener_url(opener_url);
-  content::RenderProcessHost* render_process_host =
+  RenderProcessHost* render_process_host =
       render_view_host->GetProcess();
   RenderViewHost::FilterURL(
       render_process_host->GetID(),
       false,
       &validated_url);
   RenderViewHost::FilterURL(
       render_process_host->GetID(),
       true,
       &validated_opener_url);
 
   // Notify observers about the start of the provisional load.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DidStartProvisionalLoadForFrame(frame_id, parent_frame_id,
                     is_main_frame, validated_url, is_error_page,
                     render_view_host));
 
   if (is_main_frame) {
     // Notify observers about the provisional change in the main frame URL.
     FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                       ProvisionalChangeToMainFrameUrl(validated_url,
                                                       validated_opener_url,
                                                       render_view_host));
   }
 }
 
 void WebContentsImpl::DidRedirectProvisionalLoad(
-    content::RenderViewHost* render_view_host,
+    RenderViewHost* render_view_host,
     int32 page_id,
     const GURL& opener_url,
     const GURL& source_url,
     const GURL& target_url) {
   // TODO(creis): Remove this method and have the pre-rendering code listen to
   // the ResourceDispatcherHost's RESOURCE_RECEIVED_REDIRECT notification
   // instead.  See http://crbug.com/78512.
   GURL validated_source_url(source_url);
   GURL validated_target_url(target_url);
   GURL validated_opener_url(opener_url);
-  content::RenderProcessHost* render_process_host =
+  RenderProcessHost* render_process_host =
       render_view_host->GetProcess();
   RenderViewHostImpl::FilterURL(
       ChildProcessSecurityPolicyImpl::GetInstance(),
       render_process_host->GetID(),
       false,
       &validated_source_url);
   RenderViewHostImpl::FilterURL(
       ChildProcessSecurityPolicyImpl::GetInstance(),
       render_process_host->GetID(),
       false,
@@ skipping 14 matching lines @@
     return;
 
   // Notify observers about the provisional change in the main frame URL.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     ProvisionalChangeToMainFrameUrl(validated_target_url,
                                                     validated_opener_url,
                                                     render_view_host));
 }
 
 void WebContentsImpl::DidFailProvisionalLoadWithError(
-    content::RenderViewHost* render_view_host,
+    RenderViewHost* render_view_host,
     const ViewHostMsg_DidFailProvisionalLoadWithError_Params& params) {
   VLOG(1) << "Failed Provisional Load: " << params.url.possibly_invalid_spec()
           << ", error_code: " << params.error_code
           << ", error_description: " << params.error_description
           << ", is_main_frame: " << params.is_main_frame
           << ", showing_repost_interstitial: " <<
             params.showing_repost_interstitial
           << ", frame_id: " << params.frame_id;
   GURL validated_url(params.url);
-  content::RenderProcessHost* render_process_host =
+  RenderProcessHost* render_process_host =
       render_view_host->GetProcess();
   RenderViewHost::FilterURL(
       render_process_host->GetID(),
       false,
       &validated_url);
 
   if (net::ERR_ABORTED == params.error_code) {
     // EVIL HACK ALERT! Ignore failed loads when we're showing interstitials.
     // This means that the interstitial won't be torn down properly, which is
     // bad. But if we have an interstitial, go back to another tab type, and
@@ skipping 41 matching lines @@
     const std::string& mime_type,
     ResourceType::Type resource_type) {
   base::StatsCounter cache("WebKit.CacheHit");
   cache.Increment();
 
   // Send out a notification that we loaded a resource from our memory cache.
   int cert_id = 0;
   net::CertStatus cert_status = 0;
   int security_bits = -1;
   int connection_status = 0;
-  content::DeserializeSecurityInfo(security_info, &cert_id, &cert_status,
-                                   &security_bits, &connection_status);
-  content::LoadFromMemoryCacheDetails details(
+  DeserializeSecurityInfo(security_info, &cert_id, &cert_status,
+                          &security_bits, &connection_status);
+  LoadFromMemoryCacheDetails details(
       url, GetRenderProcessHost()->GetID(), cert_id, cert_status, http_method,
       mime_type, resource_type);
 
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_LOAD_FROM_MEMORY_CACHE,
-      content::Source<NavigationController>(&controller_),
-      content::Details<content::LoadFromMemoryCacheDetails>(&details));
+  NotificationService::current()->Notify(
+      NOTIFICATION_LOAD_FROM_MEMORY_CACHE,
+      Source<NavigationController>(&controller_),
+      Details<LoadFromMemoryCacheDetails>(&details));
 }
 
 void WebContentsImpl::OnDidDisplayInsecureContent() {
-  content::RecordAction(UserMetricsAction("SSL.DisplayedInsecureContent"));
+  RecordAction(UserMetricsAction("SSL.DisplayedInsecureContent"));
   displayed_insecure_content_ = true;
   SSLManager::NotifySSLInternalStateChanged(&GetController());
 }
 
 void WebContentsImpl::OnDidRunInsecureContent(
     const std::string& security_origin, const GURL& target_url) {
   LOG(INFO) << security_origin << " ran insecure content from "
             << target_url.possibly_invalid_spec();
-  content::RecordAction(UserMetricsAction("SSL.RanInsecureContent"));
+  RecordAction(UserMetricsAction("SSL.RanInsecureContent"));
   if (EndsWith(security_origin, kDotGoogleDotCom, false))
-    content::RecordAction(UserMetricsAction("SSL.RanInsecureContentGoogle"));
+    RecordAction(UserMetricsAction("SSL.RanInsecureContentGoogle"));
   controller_.ssl_manager()->DidRunInsecureContent(security_origin);
   displayed_insecure_content_ = true;
   SSLManager::NotifySSLInternalStateChanged(&GetController());
 }
 
 void WebContentsImpl::OnDocumentLoadedInFrame(int64 frame_id) {
   controller_.DocumentLoadedInFrame();
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DocumentLoadedInFrame(frame_id, message_source_));
 }
@@ skipping 28 matching lines @@
 void WebContentsImpl::OnGoToEntryAtOffset(int offset) {
   if (!delegate_ || delegate_->OnGoToEntryOffset(offset)) {
     NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
         controller_.GetEntryAtOffset(offset));
     if (!entry)
       return;
     // Note that we don't call NavigationController::GotToOffset() as we don't
     // want to create a pending navigation entry (it might end up lingering
     // http://crbug.com/51680).
     entry->SetTransitionType(
-        content::PageTransitionFromInt(
+        PageTransitionFromInt(
             entry->GetTransitionType() |
-            content::PAGE_TRANSITION_FORWARD_BACK));
+            PAGE_TRANSITION_FORWARD_BACK));
     NavigateToEntry(*entry, NavigationControllerImpl::NO_RELOAD);
 
     // If the entry is being restored and doesn't have a SiteInstance yet, fill
     // it in now that we know. This allows us to find the entry when it commits.
     if (!entry->site_instance() &&
         entry->restore_type() != NavigationEntryImpl::RESTORE_NONE) {
       entry->set_site_instance(
           static_cast<SiteInstanceImpl*>(GetPendingSiteInstance()));
     }
   }
 }
 
 void WebContentsImpl::OnUpdateZoomLimits(int minimum_percent,
                                          int maximum_percent,
                                          bool remember) {
   minimum_zoom_percent_ = minimum_percent;
   maximum_zoom_percent_ = maximum_percent;
   temporary_zoom_settings_ = !remember;
 }
 
 void WebContentsImpl::OnSaveURL(const GURL& url,
-                                const content::Referrer& referrer) {
+                                const Referrer& referrer) {
   download_stats::RecordDownloadSource(
       download_stats::INITIATED_BY_PEPPER_SAVE);
   // Check if the URL to save matches the URL of the main frame. Since this
   // message originates from Pepper plugins, it may not be the case if the
   // plugin is an embedded element.
   GURL main_frame_url = GetURL();
   if (!main_frame_url.is_valid())
     return;
   bool is_main_frame = (url == main_frame_url);
   SaveURL(url, referrer, is_main_frame);
@@ skipping 137 matching lines @@
   // For more info, see comment above classes BrowserPluginEmbedder and
   // BrowserPluginGuest.
   // The first BrowserPluginHostMsg_CreateGuest message from this WebContents'
   // embedder render process is handled here. Once BrowserPluginEmbedder is
   // created, all subsequent BrowserPluginHostMsg_CreateGuest messages are
   // intercepted by the BrowserPluginEmbedderHelper and handled by the
   // BrowserPluginEmbedder. Thus, this code will not be executed if a
   // BrowserPluginEmbedder exists for this WebContents.
   CHECK(!browser_plugin_embedder_.get());
   browser_plugin_embedder_.reset(
-      content::BrowserPluginEmbedder::Create(this, GetRenderViewHost()));
+      BrowserPluginEmbedder::Create(this, GetRenderViewHost()));
   browser_plugin_embedder_->CreateGuest(GetRenderViewHost(),
                                         instance_id,
                                         storage_partition_id,
                                         persist_storage);
 }
 
 // Notifies the RenderWidgetHost instance about the fact that the page is
 // loading, or done loading and calls the base implementation.
 void WebContentsImpl::SetIsLoading(bool is_loading,
                                    LoadNotificationDetails* details) {
   if (is_loading == is_loading_)
     return;
 
   if (!is_loading) {
     load_state_ = net::LoadStateWithParam(net::LOAD_STATE_IDLE, string16());
     load_state_host_.clear();
     upload_size_ = 0;
     upload_position_ = 0;
   }
 
   render_manager_.SetIsLoading(is_loading);
 
   is_loading_ = is_loading;
   waiting_for_response_ = is_loading;
 
   if (delegate_)
     delegate_->LoadingStateChanged(this);
-  NotifyNavigationStateChanged(content::INVALIDATE_TYPE_LOAD);
+  NotifyNavigationStateChanged(INVALIDATE_TYPE_LOAD);
 
-  int type = is_loading ? content::NOTIFICATION_LOAD_START :
-      content::NOTIFICATION_LOAD_STOP;
-  content::NotificationDetails det = content::NotificationService::NoDetails();
+  int type = is_loading ? NOTIFICATION_LOAD_START : NOTIFICATION_LOAD_STOP;
+  NotificationDetails det = NotificationService::NoDetails();
   if (details)
-      det = content::Details<LoadNotificationDetails>(details);
-  content::NotificationService::current()->Notify(type,
-      content::Source<NavigationController>(&controller_),
-      det);
+      det = Details<LoadNotificationDetails>(details);
+  NotificationService::current()->Notify(
+      type, Source<NavigationController>(&controller_), det);
 }
 
 void WebContentsImpl::DidNavigateMainFramePostCommit(
-    const content::LoadCommittedDetails& details,
+    const LoadCommittedDetails& details,
     const ViewHostMsg_FrameNavigate_Params& params) {
   if (opener_web_ui_type_ != WebUI::kNoWebUI) {
     // If this is a window.open navigation, use the same WebUI as the renderer
     // that opened the window, as long as both renderers have the same
     // privileges.
     if (delegate_ && opener_web_ui_type_ == GetWebUITypeForCurrentState()) {
       WebUIImpl* web_ui = static_cast<WebUIImpl*>(CreateWebUI(GetURL()));
       // web_ui might be NULL if the URL refers to a non-existent extension.
       if (web_ui) {
         render_manager_.SetWebUIPostCommit(web_ui);
@@ skipping 19 matching lines @@
     displayed_insecure_content_ = false;
   }
 
   // Notify observers about navigation.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DidNavigateMainFrame(details, params));
 }
 
 void WebContentsImpl::DidNavigateAnyFramePostCommit(
     RenderViewHost* render_view_host,
-    const content::LoadCommittedDetails& details,
+    const LoadCommittedDetails& details,
     const ViewHostMsg_FrameNavigate_Params& params) {
   // If we navigate off the page, reset JavaScript state. This does nothing
   // to prevent a malicious script from spamming messages, since the script
   // could just reload the page to stop blocking.
   if (dialog_creator_ && !details.is_in_page) {
     dialog_creator_->ResetJavaScriptState(this);
     dialog_creator_ = NULL;
   }
 
   // Notify observers about navigation.
@@ skipping 41 matching lines @@
   } else {
     if (page_title_when_no_navigation_entry_ == final_title)
       return false;  // Nothing changed, don't bother.
 
     page_title_when_no_navigation_entry_ = final_title;
   }
 
   // Lastly, set the title for the view.
   view_->SetPageTitle(final_title);
 
-  std::pair<content::NavigationEntry*, bool> details =
+  std::pair<NavigationEntry*, bool> details =
       std::make_pair(entry, explicit_set);
 
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_WEB_CONTENTS_TITLE_UPDATED,
-      content::Source<WebContents>(this),
-      content::Details<std::pair<content::NavigationEntry*, bool> >(&details));
+  NotificationService::current()->Notify(
+      NOTIFICATION_WEB_CONTENTS_TITLE_UPDATED,
+      Source<WebContents>(this),
+      Details<std::pair<NavigationEntry*, bool> >(&details));
 
   return true;
 }
 
 void WebContentsImpl::NotifySwapped() {
   // After sending out a swap notification, we need to send a disconnect
   // notification so that clients that pick up a pointer to |this| can NULL the
   // pointer.  See Bug 1230284.
   notify_disconnection_ = true;
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_WEB_CONTENTS_SWAPPED,
-      content::Source<WebContents>(this),
-      content::NotificationService::NoDetails());
+  NotificationService::current()->Notify(
+      NOTIFICATION_WEB_CONTENTS_SWAPPED,
+      Source<WebContents>(this),
+      NotificationService::NoDetails());
 
   // Ensure that the associated embedder gets cleared after a RenderViewHost
   // gets swapped, so we don't reuse the same embedder next time a
   // RenderViewHost is attached to this WebContents.
   RemoveBrowserPluginEmbedder();
 }
 
 void WebContentsImpl::NotifyConnected() {
   notify_disconnection_ = true;
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_WEB_CONTENTS_CONNECTED,
-      content::Source<WebContents>(this),
-      content::NotificationService::NoDetails());
+  NotificationService::current()->Notify(
+      NOTIFICATION_WEB_CONTENTS_CONNECTED,
+      Source<WebContents>(this),
+      NotificationService::NoDetails());
 }
 
 void WebContentsImpl::NotifyDisconnected() {
   if (!notify_disconnection_)
     return;
 
   notify_disconnection_ = false;
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
-      content::Source<WebContents>(this),
-      content::NotificationService::NoDetails());
+  NotificationService::current()->Notify(
+      NOTIFICATION_WEB_CONTENTS_DISCONNECTED,
+      Source<WebContents>(this),
+      NotificationService::NoDetails());
 }
 
 RenderViewHostDelegateView* WebContentsImpl::GetDelegateView() {
   return render_view_host_delegate_view_;
 }
 
 RenderViewHostDelegate::RendererManagement*
 WebContentsImpl::GetRendererManagementDelegate() {
   return &render_manager_;
 }
 
-content::RendererPreferences WebContentsImpl::GetRendererPrefs(
-    content::BrowserContext* browser_context) const {
+RendererPreferences WebContentsImpl::GetRendererPrefs(
+    BrowserContext* browser_context) const {
   return renderer_preferences_;
 }
 
 WebContents* WebContentsImpl::GetAsWebContents() {
   return this;
 }
 
 gfx::Rect WebContentsImpl::GetRootWindowResizerRect() const {
   if (delegate_)
     return delegate_->GetRootWindowResizerRect();
   return gfx::Rect();
 }
 
 void WebContentsImpl::RemoveBrowserPluginEmbedder() {
   if (browser_plugin_embedder_.get())
     browser_plugin_embedder_.reset();
 }
 
 void WebContentsImpl::RenderViewCreated(RenderViewHost* render_view_host) {
   // Don't send notifications if we are just creating a swapped-out RVH for
   // the opener chain.  These won't be used for view-source or WebUI, so it's
   // ok to return early.
   if (static_cast<RenderViewHostImpl*>(render_view_host)->is_swapped_out())
     return;
 
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
-      content::Source<WebContents>(this),
-      content::Details<RenderViewHost>(render_view_host));
+  NotificationService::current()->Notify(
+      NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED,
+      Source<WebContents>(this),
+      Details<RenderViewHost>(render_view_host));
   NavigationEntry* entry = controller_.GetActiveEntry();
   if (!entry)
     return;
 
   // When we're creating views, we're still doing initial setup, so we always
   // use the pending Web UI rather than any possibly existing committed one.
   if (render_manager_.pending_web_ui())
     render_manager_.pending_web_ui()->RenderViewCreated(render_view_host);
 
   if (entry->IsViewSourceMode()) {
@@ skipping 48 matching lines @@
 }
 
 void WebContentsImpl::RenderViewDeleted(RenderViewHost* rvh) {
   render_manager_.RenderViewDeleted(rvh);
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, RenderViewDeleted(rvh));
 }
 
 void WebContentsImpl::DidNavigate(
     RenderViewHost* rvh,
     const ViewHostMsg_FrameNavigate_Params& params) {
-  if (content::PageTransitionIsMainFrame(params.transition))
+  if (PageTransitionIsMainFrame(params.transition))
     render_manager_.DidNavigateMainFrame(rvh);
 
   // Update the site of the SiteInstance if it doesn't have one yet, unless
   // this is for about:blank.  In that case, the SiteInstance can still be
   // considered unused until a navigation to a real page.
   if (!static_cast<SiteInstanceImpl*>(GetSiteInstance())->HasSite() &&
       params.url != GURL(chrome::kAboutBlankURL)) {
     static_cast<SiteInstanceImpl*>(GetSiteInstance())->SetSite(params.url);
   }
 
   // Need to update MIME type here because it's referred to in
   // UpdateNavigationCommands() called by RendererDidNavigate() to
   // determine whether or not to enable the encoding menu.
   // It's updated only for the main frame. For a subframe,
   // RenderView::UpdateURL does not set params.contents_mime_type.
   // (see http://code.google.com/p/chromium/issues/detail?id=2929 )
   // TODO(jungshik): Add a test for the encoding menu to avoid
   // regressing it again.
-  if (content::PageTransitionIsMainFrame(params.transition))
+  if (PageTransitionIsMainFrame(params.transition))
     contents_mime_type_ = params.contents_mime_type;
 
-  content::LoadCommittedDetails details;
+  LoadCommittedDetails details;
   bool did_navigate = controller_.RendererDidNavigate(params, &details);
 
   // Send notification about committed provisional loads. This notification is
   // different from the NAV_ENTRY_COMMITTED notification which doesn't include
   // the actual URL navigated to and isn't sent for AUTO_SUBFRAME navigations.
-  if (details.type != content::NAVIGATION_TYPE_NAV_IGNORE) {
+  if (details.type != NAVIGATION_TYPE_NAV_IGNORE) {
     // For AUTO_SUBFRAME navigations, an event for the main frame is generated
     // that is not recorded in the navigation history. For the purpose of
     // tracking navigation events, we treat this event as a sub frame navigation
     // event.
     bool is_main_frame = did_navigate ? details.is_main_frame : false;
-    content::PageTransition transition_type = params.transition;
+    PageTransition transition_type = params.transition;
     // Whether or not a page transition was triggered by going backward or
     // forward in the history is only stored in the navigation controller's
     // entry list.
     if (did_navigate &&
         (controller_.GetActiveEntry()->GetTransitionType() &
-            content::PAGE_TRANSITION_FORWARD_BACK)) {
-      transition_type = content::PageTransitionFromInt(
-          params.transition | content::PAGE_TRANSITION_FORWARD_BACK);
+            PAGE_TRANSITION_FORWARD_BACK)) {
+      transition_type = PageTransitionFromInt(
+          params.transition | PAGE_TRANSITION_FORWARD_BACK);
     }
     // Notify observers about the commit of the provisional load.
     FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                       DidCommitProvisionalLoadForFrame(params.frame_id,
                       is_main_frame, params.url, transition_type, rvh));
   }
 
   if (!did_navigate)
     return;  // No navigation happened.
 
@@ skipping 54 matching lines @@
   if (!entry && rvh != GetRenderViewHost())
     return;
 
   // TODO(evan): make use of title_direction.
   // http://code.google.com/p/chromium/issues/detail?id=27094
   if (!UpdateTitleForEntry(entry, title))
     return;
 
   // Broadcast notifications when the UI should be updated.
   if (entry == controller_.GetEntryAtOffset(0))
-    NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TITLE);
+    NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE);
 }
 
 void WebContentsImpl::UpdateEncoding(RenderViewHost* render_view_host,
                                      const std::string& encoding) {
   SetEncoding(encoding);
 }
 
 void WebContentsImpl::UpdateTargetURL(int32 page_id, const GURL& url) {
   if (delegate_)
     delegate_->UpdateTargetURL(this, page_id, url);
@@ skipping 20 matching lines @@
 void WebContentsImpl::SwappedOut(RenderViewHost* rvh) {
   if (delegate_ && rvh == GetRenderViewHost())
     delegate_->SwappedOut(this);
 }
 
 void WebContentsImpl::RequestMove(const gfx::Rect& new_bounds) {
   if (delegate_ && delegate_->IsPopupOrPanel(this))
     delegate_->MoveContents(this, new_bounds);
 }
 
-void WebContentsImpl::DidStartLoading(
-    content::RenderViewHost* render_view_host) {
+void WebContentsImpl::DidStartLoading(RenderViewHost* render_view_host) {
   SetIsLoading(true, NULL);
 
   if (delegate_ && content_restrictions_)
     OnUpdateContentRestrictions(0);
 
   // Notify observers about navigation.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DidStartLoading(render_view_host));
 }
 
-void WebContentsImpl::DidStopLoading(
-    content::RenderViewHost* render_view_host) {
+void WebContentsImpl::DidStopLoading(RenderViewHost* render_view_host) {
   scoped_ptr<LoadNotificationDetails> details;
 
   NavigationEntry* entry = controller_.GetActiveEntry();
   // An entry may not exist for a stop when loading an initial blank page or
   // if an iframe injected by script into a blank page finishes loading.
   if (entry) {
     base::TimeDelta elapsed = base::TimeTicks::Now() - current_load_start_;
 
     details.reset(new LoadNotificationDetails(
         entry->GetVirtualURL(),
         entry->GetTransitionType(),
         elapsed,
         &controller_,
         controller_.GetCurrentEntryIndex()));
   }
 
   SetIsLoading(false, details.get());
 
   // Notify observers about navigation.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DidStopLoading(render_view_host));
 }
 
 void WebContentsImpl::DidCancelLoading() {
   controller_.DiscardNonCommittedEntries();
 
   // Update the URL display.
-  NotifyNavigationStateChanged(content::INVALIDATE_TYPE_URL);
+  NotifyNavigationStateChanged(INVALIDATE_TYPE_URL);
 }
 
 void WebContentsImpl::DidChangeLoadProgress(double progress) {
   if (delegate_)
     delegate_->LoadProgressChanged(this, progress);
 }
 
 void WebContentsImpl::DidUpdateFrameTree(RenderViewHost* rvh) {
   render_manager_.DidUpdateFrameTree(rvh);
 }
 
 void WebContentsImpl::DocumentAvailableInMainFrame(
     RenderViewHost* render_view_host) {
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     DocumentAvailableInMainFrame());
 }
 
 void WebContentsImpl::DocumentOnLoadCompletedInMainFrame(
     RenderViewHost* render_view_host,
     int32 page_id) {
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
-      content::Source<WebContents>(this),
-      content::Details<int>(&page_id));
+  NotificationService::current()->Notify(
+      NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
+      Source<WebContents>(this),
+      Details<int>(&page_id));
 }
 
 void WebContentsImpl::RequestOpenURL(RenderViewHost* rvh,
                                      const GURL& url,
-                                     const content::Referrer& referrer,
+                                     const Referrer& referrer,
                                      WindowOpenDisposition disposition,
                                      int64 source_frame_id) {
   // If this came from a swapped out RenderViewHost, we only allow the request
   // if we are still in the same BrowsingInstance.
   if (static_cast<RenderViewHostImpl*>(rvh)->is_swapped_out() &&
       !rvh->GetSiteInstance()->IsRelatedSiteInstance(GetSiteInstance())) {
     return;
   }
 
   // Delegate to RequestTransferURL because this is just the generic
   // case where |old_request_id| is empty.
   RequestTransferURL(url, referrer, disposition, source_frame_id,
                      GlobalRequestID());
 }
 
 void WebContentsImpl::RequestTransferURL(
     const GURL& url,
-    const content::Referrer& referrer,
+    const Referrer& referrer,
     WindowOpenDisposition disposition,
     int64 source_frame_id,
     const GlobalRequestID& old_request_id) {
   WebContents* new_contents = NULL;
-  content::PageTransition transition_type = content::PAGE_TRANSITION_LINK;
+  PageTransition transition_type = PAGE_TRANSITION_LINK;
   if (render_manager_.web_ui()) {
     // When we're a Web UI, it will provide a page transition type for us (this
     // is so the new tab page can specify AUTO_BOOKMARK for automatically
     // generated suggestions).
     //
     // Note also that we hide the referrer for Web UI pages. We don't really
     // want web sites to see a referrer of "chrome://blah" (and some
     // chrome: URLs might have search terms or other stuff we don't want to
     // send to the site), so we send no referrer.
-    OpenURLParams params(url, content::Referrer(), source_frame_id, disposition,
+    OpenURLParams params(url, Referrer(), source_frame_id, disposition,
         render_manager_.web_ui()->GetLinkTransitionType(),
         false /* is_renderer_initiated */);
     params.transferred_global_request_id = old_request_id;
     new_contents = OpenURL(params);
     transition_type = render_manager_.web_ui()->GetLinkTransitionType();
   } else {
     OpenURLParams params(url, referrer, source_frame_id, disposition,
-        content::PAGE_TRANSITION_LINK, true /* is_renderer_initiated */);
+        PAGE_TRANSITION_LINK, true /* is_renderer_initiated */);
     params.transferred_global_request_id = old_request_id;
     new_contents = OpenURL(params);
   }
   if (new_contents) {
     // Notify observers.
     FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                       DidOpenRequestedURL(new_contents,
                                           url,
                                           referrer,
                                           disposition,
@@ skipping 68 matching lines @@
   // It is possible to receive it from one that has just been swapped in,
   // in which case we might as well deliver the message anyway.
   Send(new ViewMsg_PostMessageEvent(GetRoutingID(), new_params));
 }
 
 void WebContentsImpl::RunJavaScriptMessage(
     RenderViewHost* rvh,
     const string16& message,
     const string16& default_prompt,
     const GURL& frame_url,
-    content::JavaScriptMessageType javascript_message_type,
+    JavaScriptMessageType javascript_message_type,
     IPC::Message* reply_msg,
     bool* did_suppress_message) {
   // Suppress JavaScript dialogs when requested. Also suppress messages when
   // showing an interstitial as it's shown over the previous page and we don't
   // want the hidden page's dialogs to interfere with the interstitial.
   bool suppress_this_message =
       static_cast<RenderViewHostImpl*>(rvh)->is_swapped_out() ||
       ShowingInterstitialPage() ||
       !delegate_ ||
       delegate_->ShouldSuppressDialogs() ||
       !delegate_->GetJavaScriptDialogCreator();
 
   if (!suppress_this_message) {
-    std::string accept_lang = content::GetContentClient()->browser()->
+    std::string accept_lang = GetContentClient()->browser()->
       GetAcceptLangs(GetBrowserContext());
     dialog_creator_ = delegate_->GetJavaScriptDialogCreator();
     dialog_creator_->RunJavaScriptDialog(
         this,
         frame_url.GetOrigin(),
         accept_lang,
         javascript_message_type,
         message,
         default_prompt,
         base::Bind(&WebContentsImpl::OnDialogClosed,
@@ skipping 51 matching lines @@
 
 WebPreferences WebContentsImpl::GetWebkitPrefs() {
   // We want to base the page config off of the real URL, rather than the
   // display URL.
   GURL url = controller_.GetActiveEntry()
       ? controller_.GetActiveEntry()->GetURL() : GURL::EmptyGURL();
   return GetWebkitPrefs(GetRenderViewHost(), url);
 }
 
 int WebContentsImpl::CreateSwappedOutRenderView(
-    content::SiteInstance* instance) {
+    SiteInstance* instance) {
   return render_manager_.CreateRenderView(instance, MSG_ROUTING_NONE, true);
 }
 
 void WebContentsImpl::OnUserGesture() {
   // Notify observers.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, DidGetUserGesture());
 
   ResourceDispatcherHostImpl* rdh = ResourceDispatcherHostImpl::Get();
   if (rdh)  // NULL in unittests.
     rdh->OnUserGesture(this);
 }
 
 void WebContentsImpl::OnIgnoredUIEvent() {
   // Notify observers.
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, DidGetIgnoredUIEvent());
 }
 
 void WebContentsImpl::RendererUnresponsive(RenderViewHost* rvh,
                                            bool is_during_unload) {
   // Don't show hung renderer dialog for a swapped out RVH.
   if (rvh != GetRenderViewHost())
     return;
 
   RenderViewHostImpl* rvhi = static_cast<RenderViewHostImpl*>(rvh);
 
   // Ignore renderer unresponsive event if debugger is attached to the tab
   // since the event may be a result of the renderer sitting on a breakpoint.
   // See http://crbug.com/65458
   DevToolsAgentHost* agent =
-      content::DevToolsAgentHostRegistry::GetDevToolsAgentHost(rvh);
+      DevToolsAgentHostRegistry::GetDevToolsAgentHost(rvh);
   if (agent &&
       DevToolsManagerImpl::GetInstance()->GetDevToolsClientHostFor(agent))
     return;
 
   if (is_during_unload) {
     // Hang occurred while firing the beforeunload/unload handler.
     // Pretend the handler fired so tab closing continues as if it had.
     rvhi->set_sudden_termination_allowed(true);
 
     if (!render_manager_.ShouldCloseTabOnUnresponsiveRenderer())
@@ skipping 21 matching lines @@
 
 void WebContentsImpl::LoadStateChanged(
     const GURL& url,
     const net::LoadStateWithParam& load_state,
     uint64 upload_position,
     uint64 upload_size) {
   load_state_ = load_state;
   upload_position_ = upload_position;
   upload_size_ = upload_size;
   load_state_host_ = net::IDNToUnicode(url.host(),
-      content::GetContentClient()->browser()->GetAcceptLangs(
+      GetContentClient()->browser()->GetAcceptLangs(
           GetBrowserContext()));
   if (load_state_.state == net::LOAD_STATE_READING_RESPONSE)
     SetNotWaitingForResponse();
   if (IsLoading()) {
-    NotifyNavigationStateChanged(
-        content::INVALIDATE_TYPE_LOAD | content::INVALIDATE_TYPE_TAB);
+    NotifyNavigationStateChanged(INVALIDATE_TYPE_LOAD | INVALIDATE_TYPE_TAB);
   }
 }
 
 void WebContentsImpl::WorkerCrashed() {
   if (delegate_)
     delegate_->WorkerCrashed(this);
 }
 
 void WebContentsImpl::BeforeUnloadFiredFromRenderManager(
     bool proceed, const base::TimeTicks& proceed_time,
@@ skipping 121 matching lines @@
 
     close_start_time_ = base::TimeTicks();
     before_unload_end_time_ = base::TimeTicks();
   }
   is_showing_before_unload_dialog_ = false;
   static_cast<RenderViewHostImpl*>(
       rvh)->JavaScriptDialogClosed(reply_msg, success, user_input);
 }
 
 void WebContentsImpl::SetEncoding(const std::string& encoding) {
-  encoding_ = content::GetContentClient()->browser()->
+  encoding_ = GetContentClient()->browser()->
       GetCanonicalEncodingNameByAliasName(encoding);
 }
 
 void WebContentsImpl::SaveURL(const GURL& url,
-                              const content::Referrer& referrer,
+                              const Referrer& referrer,
                               bool is_main_frame) {
   DownloadManager* dlm =
       BrowserContext::GetDownloadManager(GetBrowserContext());
   if (!dlm)
     return;
   int64 post_id = -1;
   if (is_main_frame) {
     const NavigationEntry* entry = controller_.GetActiveEntry();
     if (entry)
       post_id = entry->GetPostID();
   }
-  scoped_ptr<content::DownloadSaveInfo> save_info(
-      new content::DownloadSaveInfo());
+  scoped_ptr<DownloadSaveInfo> save_info(new DownloadSaveInfo());
   save_info->prompt_for_save_location = true;
   scoped_ptr<DownloadUrlParameters> params(
       DownloadUrlParameters::FromWebContents(this, url, save_info.Pass()));
   params->set_referrer(referrer);
   params->set_post_id(post_id);
   params->set_prefer_cache(true);
   if (post_id >= 0)
     params->set_method("POST");
   dlm->DownloadUrl(params.Pass());
 }
 
 void WebContentsImpl::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = GetView()->CreateViewForWidget(rvh);
   // Can be NULL during tests.
   if (rwh_view)
     rwh_view->SetSize(GetView()->GetContainerSize());
 }
 
 RenderViewHostImpl* WebContentsImpl::GetRenderViewHostImpl() {
   return static_cast<RenderViewHostImpl*>(GetRenderViewHost());
 }
 
 void WebContentsImpl::GetBrowserPluginEmbedderInfo(
-    content::RenderViewHost* render_view_host,
+    RenderViewHost* render_view_host,
     std::string* embedder_channel_name,
     int* embedder_container_id) {
-  content::RenderProcessHost* embedder_render_process_host =
+  RenderProcessHost* embedder_render_process_host =
       old_browser_plugin_host()->embedder_render_process_host();
   *embedder_container_id = old_browser_plugin_host()->instance_id();
   int embedder_process_id =
       embedder_render_process_host ? embedder_render_process_host->GetID() : -1;
   if (embedder_process_id != -1) {
     *embedder_channel_name =
         StringPrintf("%d.r%d", render_view_host->GetProcess()->GetID(),
                      embedder_process_id);
   }
 }
 
-content::BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() {
+BrowserPluginGuest* WebContentsImpl::GetBrowserPluginGuest() {
   return browser_plugin_guest_.get();
 }
 
-content::BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() {
+BrowserPluginEmbedder* WebContentsImpl::GetBrowserPluginEmbedder() {
   return browser_plugin_embedder_.get();
 }
+
+}  // namespace content