Move a bunch more code into the content namespace.

content/browser/web_contents/interstitial_page_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/interstitial_page_impl.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ skipping 21 matching lines @@
 #include "content/public/browser/invalidate_type.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/page_transition_types.h"
 #include "net/base/escape.h"
 #include "net/url_request/url_request_context_getter.h"
 
-using content::BrowserThread;
-using content::DomOperationNotificationDetails;
-using content::InterstitialPageDelegate;
-using content::NativeWebKeyboardEvent;
-using content::NavigationController;
-using content::NavigationEntry;
-using content::NavigationEntryImpl;
-using content::RenderViewHost;
-using content::RenderViewHostImpl;
-using content::RenderViewHostDelegate;
-using content::RenderViewHostDelegateView;
-using content::RenderWidgetHost;
-using content::RenderWidgetHostImpl;
-using content::RenderWidgetHostView;
-using content::RenderWidgetHostViewPort;
-using content::ResourceDispatcherHostImpl;
-using content::SessionStorageNamespace;
-using content::SiteInstance;
-using content::WebContents;
-using content::WebContentsView;
 using WebKit::WebDragOperation;
 using WebKit::WebDragOperationsMask;
 
+namespace content {
 namespace {
 
 void ResourceRequestHelper(ResourceDispatcherHostImpl* rdh,
                            int process_id,
                            int render_view_host_id,
                            ResourceRequestAction action) {
   switch (action) {
     case BLOCK:
       rdh->BlockRequestsForRoute(process_id, render_view_host_id);
       break;
     case RESUME:
       rdh->ResumeBlockedRequestsForRoute(process_id, render_view_host_id);
       break;
     case CANCEL:
       rdh->CancelBlockedRequestsForRoute(process_id, render_view_host_id);
       break;
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace
 
 class InterstitialPageImpl::InterstitialPageRVHDelegateView
-  : public content::RenderViewHostDelegateView {
+  : public RenderViewHostDelegateView {
  public:
   explicit InterstitialPageRVHDelegateView(InterstitialPageImpl* page);
 
   // RenderViewHostDelegateView implementation:
   virtual void ShowPopupMenu(const gfx::Rect& bounds,
                              int item_height,
                              double item_font_size,
                              int selected_item,
                              const std::vector<WebMenuItem>& items,
                              bool right_aligned,
@@ skipping 23 matching lines @@
 typedef std::map<WebContents*, InterstitialPageImpl*> InterstitialPageMap;
 static InterstitialPageMap* g_web_contents_to_interstitial_page;
 
 // Initializes g_web_contents_to_interstitial_page in a thread-safe manner.
 // Should be called before accessing g_web_contents_to_interstitial_page.
 static void InitInterstitialPageMap() {
   if (!g_web_contents_to_interstitial_page)
     g_web_contents_to_interstitial_page = new InterstitialPageMap;
 }
 
-namespace content {
-
 InterstitialPage* InterstitialPage::Create(WebContents* web_contents,
                                            bool new_navigation,
                                            const GURL& url,
                                            InterstitialPageDelegate* delegate) {
   return new InterstitialPageImpl(web_contents, new_navigation, url, delegate);
 }
 
 InterstitialPage* InterstitialPage::GetInterstitialPage(
     WebContents* web_contents) {
   InitInterstitialPageMap();
   InterstitialPageMap::const_iterator iter =
       g_web_contents_to_interstitial_page->find(web_contents);
   if (iter == g_web_contents_to_interstitial_page->end())
     return NULL;
 
   return iter->second;
 }
 
-}  // namespace content
-
 InterstitialPageImpl::InterstitialPageImpl(WebContents* web_contents,
                                            bool new_navigation,
                                            const GURL& url,
                                            InterstitialPageDelegate* delegate)
     : web_contents_(static_cast<WebContentsImpl*>(web_contents)),
       url_(url),
       new_navigation_(new_navigation),
       should_discard_pending_nav_entry_(new_navigation),
       reload_on_dont_proceed_(false),
       enabled_(true),
@@ skipping 43 matching lines @@
     }
   }
 
   // Block the resource requests for the render view host while it is hidden.
   TakeActionOnResourceDispatcher(BLOCK);
   // We need to be notified when the RenderViewHost is destroyed so we can
   // cancel the blocked requests.  We cannot do that on
   // NOTIFY_WEB_CONTENTS_DESTROYED as at that point the RenderViewHost has
   // already been destroyed.
   notification_registrar_.Add(
-      this, content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
-      content::Source<RenderWidgetHost>(web_contents_->GetRenderViewHost()));
+      this, NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED,
+      Source<RenderWidgetHost>(web_contents_->GetRenderViewHost()));
 
   // Update the g_web_contents_to_interstitial_page map.
   iter = g_web_contents_to_interstitial_page->find(web_contents_);
   DCHECK(iter == g_web_contents_to_interstitial_page->end());
   (*g_web_contents_to_interstitial_page)[web_contents_] = this;
 
   if (new_navigation_) {
     NavigationEntryImpl* entry = new NavigationEntryImpl;
     entry->SetURL(url_);
     entry->SetVirtualURL(url_);
-    entry->set_page_type(content::PAGE_TYPE_INTERSTITIAL);
+    entry->set_page_type(PAGE_TYPE_INTERSTITIAL);
 
     // Give delegates a chance to set some states on the navigation entry.
     delegate_->OverrideEntry(entry);
 
     web_contents_->GetController().AddTransientEntry(entry);
   }
 
   DCHECK(!render_view_host_);
   render_view_host_ = static_cast<RenderViewHostImpl*>(CreateRenderViewHost());
   CreateWebContentsView();
 
   std::string data_url = "data:text/html;charset=utf-8," +
                          net::EscapePath(delegate_->GetHTMLContents());
   render_view_host_->NavigateToURL(GURL(data_url));
 
   notification_registrar_.Add(this,
-                              content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
-                              content::Source<WebContents>(web_contents_));
-  notification_registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
-      content::Source<NavigationController>(&web_contents_->GetController()));
-  notification_registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_PENDING,
-      content::Source<NavigationController>(&web_contents_->GetController()));
+                              NOTIFICATION_WEB_CONTENTS_DESTROYED,
+                              Source<WebContents>(web_contents_));
+  notification_registrar_.Add(this, NOTIFICATION_NAV_ENTRY_COMMITTED,
+      Source<NavigationController>(&web_contents_->GetController()));
+  notification_registrar_.Add(this, NOTIFICATION_NAV_ENTRY_PENDING,
+      Source<NavigationController>(&web_contents_->GetController()));
   notification_registrar_.Add(
-      this, content::NOTIFICATION_DOM_OPERATION_RESPONSE,
-      content::Source<RenderViewHost>(render_view_host_));
+      this, NOTIFICATION_DOM_OPERATION_RESPONSE,
+      Source<RenderViewHost>(render_view_host_));
 }
 
 void InterstitialPageImpl::Hide() {
   RenderWidgetHostView* old_view =
       web_contents_->GetRenderViewHost()->GetView();
   if (web_contents_->GetInterstitialPage() == this &&
       old_view && !old_view->IsShowing()) {
     // Show the original RVH since we're going away.  Note it might not exist if
     // the renderer crashed while the interstitial was showing.
     // Note that it is important that we don't call Show() if the view is
@@ skipping 12 matching lines @@
   }
 
   render_view_host_->Shutdown();
   render_view_host_ = NULL;
   if (web_contents_->GetInterstitialPage())
     web_contents_->remove_interstitial_page();
   // Let's revert to the original title if necessary.
   NavigationEntry* entry = web_contents_->GetController().GetActiveEntry();
   if (!new_navigation_ && should_revert_web_contents_title_) {
     entry->SetTitle(original_web_contents_title_);
-    web_contents_->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TITLE);
+    web_contents_->NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE);
   }
 
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_INTERSTITIAL_DETACHED,
-      content::Source<WebContents>(web_contents_),
-      content::NotificationService::NoDetails());
+  NotificationService::current()->Notify(
+      NOTIFICATION_INTERSTITIAL_DETACHED,
+      Source<WebContents>(web_contents_),
+      NotificationService::NoDetails());
 
   InterstitialPageMap::iterator iter =
       g_web_contents_to_interstitial_page->find(web_contents_);
   DCHECK(iter != g_web_contents_to_interstitial_page->end());
   if (iter != g_web_contents_to_interstitial_page->end())
     g_web_contents_to_interstitial_page->erase(iter);
 }
 
 void InterstitialPageImpl::Observe(
     int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
+    const NotificationSource& source,
+    const NotificationDetails& details) {
   switch (type) {
-    case content::NOTIFICATION_NAV_ENTRY_PENDING:
+    case NOTIFICATION_NAV_ENTRY_PENDING:
       // We are navigating away from the interstitial (the user has typed a URL
       // in the location bar or clicked a bookmark).  Make sure clicking on the
       // interstitial will have no effect.  Also cancel any blocked requests
       // on the ResourceDispatcherHost.  Note that when we get this notification
       // the RenderViewHost has not yet navigated so we'll unblock the
       // RenderViewHost before the resource request for the new page we are
       // navigating arrives in the ResourceDispatcherHost.  This ensures that
       // request won't be blocked if the same RenderViewHost was used for the
       // new navigation.
       Disable();
       TakeActionOnResourceDispatcher(CANCEL);
       break;
-    case content::NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED:
+    case NOTIFICATION_RENDER_WIDGET_HOST_DESTROYED:
       if (action_taken_ == NO_ACTION) {
         // The RenderViewHost is being destroyed (as part of the tab being
         // closed); make sure we clear the blocked requests.
         RenderViewHost* rvh = static_cast<RenderViewHost*>(
             static_cast<RenderViewHostImpl*>(
                 RenderWidgetHostImpl::From(
-                    content::Source<RenderWidgetHost>(source).ptr())));
+                    Source<RenderWidgetHost>(source).ptr())));
         DCHECK(rvh->GetProcess()->GetID() == original_child_id_ &&
                rvh->GetRoutingID() == original_rvh_id_);
         TakeActionOnResourceDispatcher(CANCEL);
       }
       break;
-    case content::NOTIFICATION_WEB_CONTENTS_DESTROYED:
-    case content::NOTIFICATION_NAV_ENTRY_COMMITTED:
+    case NOTIFICATION_WEB_CONTENTS_DESTROYED:
+    case NOTIFICATION_NAV_ENTRY_COMMITTED:
       if (action_taken_ == NO_ACTION) {
         // We are navigating away from the interstitial or closing a tab with an
         // interstitial.  Default to DontProceed(). We don't just call Hide as
         // subclasses will almost certainly override DontProceed to do some work
         // (ex: close pending connections).
         DontProceed();
       } else {
         // User decided to proceed and either the navigation was committed or
         // the tab was closed before that.
         Hide();
         delete this;
       }
       break;
-    case content::NOTIFICATION_DOM_OPERATION_RESPONSE:
+    case NOTIFICATION_DOM_OPERATION_RESPONSE:
       if (enabled()) {
-        content::Details<DomOperationNotificationDetails> dom_op_details(
+        Details<DomOperationNotificationDetails> dom_op_details(
             details);
         delegate_->CommandReceived(dom_op_details->json);
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 RenderViewHostDelegateView* InterstitialPageImpl::GetDelegateView() {
@@ skipping 15 matching lines @@
 void InterstitialPageImpl::DidNavigate(
     RenderViewHost* render_view_host,
     const ViewHostMsg_FrameNavigate_Params& params) {
   // A fast user could have navigated away from the page that triggered the
   // interstitial while the interstitial was loading, that would have disabled
   // us. In that case we can dismiss ourselves.
   if (!enabled_) {
     DontProceed();
     return;
   }
-  if (params.transition == content::PAGE_TRANSITION_AUTO_SUBFRAME) {
+  if (params.transition == PAGE_TRANSITION_AUTO_SUBFRAME) {
     // No need to handle navigate message from iframe in the interstitial page.
     return;
   }
 
   // The RenderViewHost has loaded its contents, we can show it now.
   render_view_host_->GetView()->Show();
   web_contents_->set_interstitial_page(this);
 
   // This notification hides the bookmark bar. Note that this has to happen
   // after the interstitial page was registered with |web_contents_|, since
   // there will be a callback to |web_contents_| testing if an interstitial page
   // is showing before hiding the bookmark bar.
-  content::NotificationService::current()->Notify(
-      content::NOTIFICATION_INTERSTITIAL_ATTACHED,
-      content::Source<WebContents>(web_contents_),
-      content::NotificationService::NoDetails());
+  NotificationService::current()->Notify(
+      NOTIFICATION_INTERSTITIAL_ATTACHED,
+      Source<WebContents>(web_contents_),
+      NotificationService::NoDetails());
 
   RenderWidgetHostView* rwh_view =
       web_contents_->GetRenderViewHost()->GetView();
 
   // The RenderViewHost may already have crashed before we even get here.
   if (rwh_view) {
     // If the page has focus, focus the interstitial.
     if (rwh_view->HasFocus())
       Focus();
 
@@ skipping 32 matching lines @@
 
   // If this interstitial is shown on an existing navigation entry, we'll need
   // to remember its title so we can revert to it when hidden.
   if (!new_navigation_ && !should_revert_web_contents_title_) {
     original_web_contents_title_ = entry->GetTitle();
     should_revert_web_contents_title_ = true;
   }
   // TODO(evan): make use of title_direction.
   // http://code.google.com/p/chromium/issues/detail?id=27094
   entry->SetTitle(title);
-  web_contents_->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TITLE);
+  web_contents_->NotifyNavigationStateChanged(INVALIDATE_TYPE_TITLE);
 }
 
-content::RendererPreferences InterstitialPageImpl::GetRendererPrefs(
-    content::BrowserContext* browser_context) const {
+RendererPreferences InterstitialPageImpl::GetRendererPrefs(
+    BrowserContext* browser_context) const {
   delegate_->OverrideRendererPrefs(&renderer_preferences_);
   return renderer_preferences_;
 }
 
 webkit_glue::WebPreferences InterstitialPageImpl::GetWebkitPrefs() {
   return WebContentsImpl::GetWebkitPrefs(render_view_host_, url_);
 }
 
 bool InterstitialPageImpl::PreHandleKeyboardEvent(
     const NativeWebKeyboardEvent& event,
     bool* is_keyboard_shortcut) {
   return web_contents_->PreHandleKeyboardEvent(event, is_keyboard_shortcut);
 }
 
 void InterstitialPageImpl::HandleKeyboardEvent(
       const NativeWebKeyboardEvent& event) {
   return web_contents_->HandleKeyboardEvent(event);
 }
 
 WebContents* InterstitialPageImpl::web_contents() const {
   return web_contents_;
 }
 
 RenderViewHost* InterstitialPageImpl::CreateRenderViewHost() {
   // Interstitial pages don't want to share the session storage so we mint a
   // new one.
-  using content::BrowserContext;
   BrowserContext* browser_context = web_contents()->GetBrowserContext();
   scoped_refptr<SiteInstance> site_instance =
       SiteInstance::Create(browser_context);
   DOMStorageContextImpl* dom_storage_context =
       static_cast<DOMStorageContextImpl*>(
           BrowserContext::GetStoragePartition(
               browser_context, site_instance)->GetDOMStorageContext());
   SessionStorageNamespaceImpl* session_storage_namespace_impl =
       new SessionStorageNamespaceImpl(dom_storage_context);
 
   RenderViewHostImpl* render_view_host = new RenderViewHostImpl(
       site_instance, this, this, MSG_ROUTING_NONE, false,
       session_storage_namespace_impl);
   web_contents_->RenderViewForInterstitialPageCreated(render_view_host);
   return render_view_host;
 }
 
 WebContentsView* InterstitialPageImpl::CreateWebContentsView() {
   if (!create_view_)
     return NULL;
   WebContentsView* web_contents_view = web_contents()->GetView();
   RenderWidgetHostView* view =
       web_contents_view->CreateViewForWidget(render_view_host_);
   render_view_host_->SetView(view);
-  render_view_host_->AllowBindings(content::BINDINGS_POLICY_DOM_AUTOMATION);
+  render_view_host_->AllowBindings(BINDINGS_POLICY_DOM_AUTOMATION);
 
   int32 max_page_id = web_contents()->
       GetMaxPageIDForSiteInstance(render_view_host_->GetSiteInstance());
   render_view_host_->CreateRenderView(string16(),
                                       MSG_ROUTING_NONE,
                                       max_page_id,
                                       std::string(),
                                       -1);
   view->SetSize(web_contents_view->GetContainerSize());
   // Don't show the interstitial until we have navigated to it.
@@ skipping 145 matching lines @@
                                              const gfx::Rect& initial_pos) {
   NOTREACHED() << "InterstitialPage does not support showing drop-downs yet.";
 }
 
 void InterstitialPageImpl::ShowCreatedFullscreenWidget(int route_id) {
   NOTREACHED()
       << "InterstitialPage does not support showing full screen popups.";
 }
 
 void InterstitialPageImpl::ShowContextMenu(
-    const content::ContextMenuParams& params,
-    content::ContextMenuSourceType type) {
+    const ContextMenuParams& params,
+    ContextMenuSourceType type) {
 }
 
 void InterstitialPageImpl::Disable() {
   enabled_ = false;
 }
 
 void InterstitialPageImpl::TakeActionOnResourceDispatcher(
     ResourceRequestAction action) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)) <<
       "TakeActionOnResourceDispatcher should be called on the main thread.";
@@ skipping 66 matching lines @@
   if (!web_contents->GetDelegateView())
     return;
 
   web_contents->GetDelegateView()->TakeFocus(reverse);
 }
 
 void InterstitialPageImpl::InterstitialPageRVHDelegateView::OnFindReply(
     int request_id, int number_of_matches, const gfx::Rect& selection_rect,
     int active_match_ordinal, bool final_update) {
 }
+
+}  // namespace content