TabContents -> WebContentsImpl, part 12.

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 109 matching lines @@
  private:
   InterstitialPageImpl* interstitial_page_;
 
   DISALLOW_COPY_AND_ASSIGN(InterstitialPageRVHViewDelegate);
 };
 
 
 // We keep a map of the various blocking pages shown as the UI tests need to
 // be able to retrieve them.
 typedef std::map<WebContents*, InterstitialPageImpl*> InterstitialPageMap;
-static InterstitialPageMap* g_tab_to_interstitial_page;
+static InterstitialPageMap* g_contents_to_interstitial_page;

[jam, 2012/04/13 18:23:21]

ditto

 
-// Initializes g_tab_to_interstitial_page in a thread-safe manner.
-// Should be called before accessing g_tab_to_interstitial_page.
+// Initializes g_contents_to_interstitial_page in a thread-safe manner.
+// Should be called before accessing g_contents_to_interstitial_page.
 static void InitInterstitialPageMap() {
-  if (!g_tab_to_interstitial_page)
-    g_tab_to_interstitial_page = new InterstitialPageMap;
+  if (!g_contents_to_interstitial_page)
+    g_contents_to_interstitial_page = new InterstitialPageMap;
 }
 
 namespace content {
 
 InterstitialPage* InterstitialPage::Create(WebContents* tab,
                                            bool new_navigation,
                                            const GURL& url,
                                            InterstitialPageDelegate* delegate) {
   return new InterstitialPageImpl(tab, new_navigation, url, delegate);
 }
 
 InterstitialPage* InterstitialPage::GetInterstitialPage(
     WebContents* web_contents) {
   InitInterstitialPageMap();
   InterstitialPageMap::const_iterator iter =
-      g_tab_to_interstitial_page->find(web_contents);
-  if (iter == g_tab_to_interstitial_page->end())
+      g_contents_to_interstitial_page->find(web_contents);
+  if (iter == g_contents_to_interstitial_page->end())
     return NULL;
 
   return iter->second;
 }
 
 }  // namespace content
 
-InterstitialPageImpl::InterstitialPageImpl(WebContents* tab,
+InterstitialPageImpl::InterstitialPageImpl(WebContents* web_contents,
                                            bool new_navigation,
                                            const GURL& url,
                                            InterstitialPageDelegate* delegate)
-    : tab_(static_cast<TabContents*>(tab)),
+    : 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),
       action_taken_(NO_ACTION),
       render_view_host_(NULL),
-      original_child_id_(tab->GetRenderProcessHost()->GetID()),
-      original_rvh_id_(tab->GetRenderViewHost()->GetRoutingID()),
-      should_revert_tab_title_(false),
-      tab_was_loading_(false),
+      original_child_id_(web_contents->GetRenderProcessHost()->GetID()),
+      original_rvh_id_(web_contents->GetRenderViewHost()->GetRoutingID()),
+      should_revert_contents_title_(false),
+      contents_was_loading_(false),
       resource_dispatcher_host_notified_(false),
       ALLOW_THIS_IN_INITIALIZER_LIST(rvh_view_delegate_(
           new InterstitialPageRVHViewDelegate(this))),
       create_view_(true),
       delegate_(delegate) {
   InitInterstitialPageMap();
   // It would be inconsistent to create an interstitial with no new navigation
   // (which is the case when the interstitial was triggered by a sub-resource on
   // a page) when we have a pending entry (in the process of loading a new top
   // frame).
-  DCHECK(new_navigation || !tab->GetController().GetPendingEntry());
+  DCHECK(new_navigation || !web_contents->GetController().GetPendingEntry());
 }
 
 InterstitialPageImpl::~InterstitialPageImpl() {
 }
 
 void InterstitialPageImpl::Show() {
   // If an interstitial is already showing or about to be shown, close it before
   // showing the new one.
   // Be careful not to take an action on the old interstitial more than once.
   InterstitialPageMap::const_iterator iter =
-      g_tab_to_interstitial_page->find(tab_);
-  if (iter != g_tab_to_interstitial_page->end()) {
+      g_contents_to_interstitial_page->find(web_contents_);
+  if (iter != g_contents_to_interstitial_page->end()) {
     InterstitialPageImpl* interstitial = iter->second;
     if (interstitial->action_taken_ != NO_ACTION) {
       interstitial->Hide();
       delete interstitial;
     } else {
       // If we are currently showing an interstitial page for which we created
       // a transient entry and a new interstitial is shown as the result of a
       // new browser initiated navigation, then that transient entry has already
       // been discarded and a new pending navigation entry created.
       // So we should not discard that new pending navigation entry.
       // See http://crbug.com/9791
       if (new_navigation_ && interstitial->new_navigation_)
         interstitial->should_discard_pending_nav_entry_= false;
       interstitial->DontProceed();
     }
   }
 
   // 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_TAB_CONTENTS_DESTROYED as at that point the RenderViewHost has
+  // 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>(tab_->GetRenderViewHost()));
+      content::Source<RenderWidgetHost>(web_contents_->GetRenderViewHost()));
 
-  // Update the g_tab_to_interstitial_page map.
-  iter = g_tab_to_interstitial_page->find(tab_);
-  DCHECK(iter == g_tab_to_interstitial_page->end());
-  (*g_tab_to_interstitial_page)[tab_] = this;
+  // Update the g_contents_to_interstitial_page map.
+  iter = g_contents_to_interstitial_page->find(web_contents_);
+  DCHECK(iter == g_contents_to_interstitial_page->end());
+  (*g_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);
 
     // Give delegates a chance to set some states on the navigation entry.
     delegate_->OverrideEntry(entry);
 
-    tab_->GetControllerImpl().AddTransientEntry(entry);
+    web_contents_->GetControllerImpl().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>(tab_));
+                              content::Source<WebContents>(web_contents_));
   notification_registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_COMMITTED,
-      content::Source<NavigationController>(&tab_->GetController()));
+      content::Source<NavigationController>(&web_contents_->GetController()));
   notification_registrar_.Add(this, content::NOTIFICATION_NAV_ENTRY_PENDING,
-      content::Source<NavigationController>(&tab_->GetController()));
+      content::Source<NavigationController>(&web_contents_->GetController()));
   notification_registrar_.Add(
       this, content::NOTIFICATION_DOM_OPERATION_RESPONSE,
       content::Source<RenderViewHost>(render_view_host_));
 }
 
 void InterstitialPageImpl::Hide() {
-  RenderWidgetHostView* old_view = tab_->GetRenderViewHost()->GetView();
-  if (tab_->GetInterstitialPage() == this &&
+  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
     // already showing. That would result in bad things (unparented HWND on
     // Windows for example) happening.
     old_view->Show();
   }
 
   // If the focus was on the interstitial, let's keep it to the page.
   // (Note that in unit-tests the RVH may not have a view).
   if (render_view_host_->GetView() &&
       render_view_host_->GetView()->HasFocus() &&
-      tab_->GetRenderViewHost()->GetView()) {
+      web_contents_->GetRenderViewHost()->GetView()) {
     RenderWidgetHostViewPort::FromRWHV(
-        tab_->GetRenderViewHost()->GetView())->Focus();
+        web_contents_->GetRenderViewHost()->GetView())->Focus();
   }
 
   render_view_host_->Shutdown();
   render_view_host_ = NULL;
-  if (tab_->GetInterstitialPage())
-    tab_->remove_interstitial_page();
+  if (web_contents_->GetInterstitialPage())
+    web_contents_->remove_interstitial_page();
   // Let's revert to the original title if necessary.
-  NavigationEntry* entry = tab_->GetController().GetActiveEntry();
-  if (!new_navigation_ && should_revert_tab_title_) {
-    entry->SetTitle(original_tab_title_);
-    tab_->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TITLE);
+  NavigationEntry* entry = web_contents_->GetController().GetActiveEntry();
+  if (!new_navigation_ && should_revert_contents_title_) {
+    entry->SetTitle(original_contents_title_);
+    web_contents_->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TITLE);
   }
 
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_INTERSTITIAL_DETACHED,
-      content::Source<WebContents>(tab_),
+      content::Source<WebContents>(web_contents_),
       content::NotificationService::NoDetails());
 
-  InterstitialPageMap::iterator iter = g_tab_to_interstitial_page->find(tab_);
-  DCHECK(iter != g_tab_to_interstitial_page->end());
-  if (iter != g_tab_to_interstitial_page->end())
-    g_tab_to_interstitial_page->erase(iter);
+  InterstitialPageMap::iterator iter =
+      g_contents_to_interstitial_page->find(web_contents_);
+  DCHECK(iter != g_contents_to_interstitial_page->end());
+  if (iter != g_contents_to_interstitial_page->end())
+    g_contents_to_interstitial_page->erase(iter);
 }
 
 void InterstitialPageImpl::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
     case content::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
@@ skipping 73 matching lines @@
     DontProceed();
     return;
   }
   if (params.transition == content::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();
-  tab_->set_interstitial_page(this);
+  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 |tab_|, since there will be
-  // a callback to |tab_| testing if an interstitial page is showing before
-  // hiding the bookmark bar.
+  // after the interstitial page was registered with |contents_|, since there
+  // will be a callback to |contents_| testing if an interstitial page is
+  // showing before hiding the bookmark bar.
   content::NotificationService::current()->Notify(
       content::NOTIFICATION_INTERSTITIAL_ATTACHED,
-      content::Source<WebContents>(tab_),
+      content::Source<WebContents>(web_contents_),
       content::NotificationService::NoDetails());
 
-  RenderWidgetHostView* rwh_view = tab_->GetRenderViewHost()->GetView();
+  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();
 
     // Hide the original RVH since we're showing the interstitial instead.
     rwh_view->Hide();
   }
 
   // Notify the tab we are not loading so the throbber is stopped. It also
   // causes a NOTIFY_LOAD_STOP notification, that the AutomationProvider (used
   // by the UI tests) expects to consider a navigation as complete. Without
   // this, navigating in a UI test to a URL that triggers an interstitial would
   // hang.
-  tab_was_loading_ = tab_->IsLoading();
-  tab_->SetIsLoading(false, NULL);
+  contents_was_loading_ = web_contents_->IsLoading();
+  web_contents_->SetIsLoading(false, NULL);
 }
 
 void InterstitialPageImpl::UpdateTitle(
     RenderViewHost* render_view_host,
     int32 page_id,
     const string16& title,
     base::i18n::TextDirection title_direction) {
   DCHECK(render_view_host == render_view_host_);
-  NavigationEntry* entry = tab_->GetController().GetActiveEntry();
+  NavigationEntry* entry = web_contents_->GetController().GetActiveEntry();
   if (!entry) {
     // Crash reports from the field indicate this can be NULL.
     // This is unexpected as InterstitialPages constructed with the
     // new_navigation flag set to true create a transient navigation entry
     // (that is returned as the active entry). And the only case so far of
     // interstitial created with that flag set to false is with the
     // SafeBrowsingBlockingPage, when the resource triggering the interstitial
     // is a sub-resource, meaning the main page has already been loaded and a
     // navigation entry should have been created.
     NOTREACHED();
     return;
   }
 
   // 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_tab_title_) {
-    original_tab_title_ = entry->GetTitle();
-    should_revert_tab_title_ = true;
+  if (!new_navigation_ && !should_revert_contents_title_) {
+    original_contents_title_ = entry->GetTitle();
+    should_revert_contents_title_ = true;
   }
   // TODO(evan): make use of title_direction.
   // http://code.google.com/p/chromium/issues/detail?id=27094
   entry->SetTitle(title);
-  tab_->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TITLE);
+  web_contents_->NotifyNavigationStateChanged(content::INVALIDATE_TYPE_TITLE);
 }
 
 content::RendererPreferences InterstitialPageImpl::GetRendererPrefs(
     content::BrowserContext* browser_context) const {
   delegate_->OverrideRendererPrefs(&renderer_preferences_);
   return renderer_preferences_;
 }
 
 WebPreferences InterstitialPageImpl::GetWebkitPrefs() {
-  return TabContents::GetWebkitPrefs(render_view_host_, url_);
+  return WebContentsImpl::GetWebkitPrefs(render_view_host_, url_);
 }
 
 bool InterstitialPageImpl::PreHandleKeyboardEvent(
     const NativeWebKeyboardEvent& event,
     bool* is_keyboard_shortcut) {
-  return tab_->PreHandleKeyboardEvent(event, is_keyboard_shortcut);
+  return web_contents_->PreHandleKeyboardEvent(event, is_keyboard_shortcut);
 }
 
 void InterstitialPageImpl::HandleKeyboardEvent(
       const NativeWebKeyboardEvent& event) {
-  return tab_->HandleKeyboardEvent(event);
+  return web_contents_->HandleKeyboardEvent(event);
 }
 
-WebContents* InterstitialPageImpl::tab() const {
-  return tab_;
+WebContents* InterstitialPageImpl::web_contents() const {
+  return web_contents_;
 }
 
 RenderViewHost* InterstitialPageImpl::CreateRenderViewHost() {
   RenderViewHostImpl* render_view_host = new RenderViewHostImpl(
-      SiteInstance::Create(tab()->GetBrowserContext()),
+      SiteInstance::Create(web_contents()->GetBrowserContext()),
       this, MSG_ROUTING_NONE, kInvalidSessionStorageNamespaceId);
   return render_view_host;
 }
 
 WebContentsView* InterstitialPageImpl::CreateWebContentsView() {
   if (!create_view_)
     return NULL;
-  WebContentsView* web_contents_view = tab()->GetView();
+  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);
 
-  int32 max_page_id =
-      tab()->GetMaxPageIDForSiteInstance(render_view_host_->GetSiteInstance());
+  int32 max_page_id = web_contents()->
+      GetMaxPageIDForSiteInstance(render_view_host_->GetSiteInstance());
   render_view_host_->CreateRenderView(string16(), max_page_id);
   view->SetSize(web_contents_view->GetContainerSize());
   // Don't show the interstitial until we have navigated to it.
   view->Hide();
   return web_contents_view;
 }
 
 void InterstitialPageImpl::Proceed() {
   if (action_taken_ != NO_ACTION) {
     NOTREACHED();
     return;
   }
   Disable();
   action_taken_ = PROCEED_ACTION;
 
   // Resumes the throbber, if applicable.
-  if (tab_was_loading_)
-    tab_->SetIsLoading(true, NULL);
+  if (contents_was_loading_)
+    web_contents_->SetIsLoading(true, NULL);
 
   // If this is a new navigation, the old page is going away, so we cancel any
   // blocked requests for it.  If it is not a new navigation, then it means the
   // interstitial was shown as a result of a resource loading in the page.
   // Since the user wants to proceed, we'll let any blocked request go through.
   if (new_navigation_)
     TakeActionOnResourceDispatcher(CANCEL);
   else
     TakeActionOnResourceDispatcher(RESUME);
 
@@ skipping 23 matching lines @@
   if (new_navigation_)
     TakeActionOnResourceDispatcher(RESUME);
   else
     TakeActionOnResourceDispatcher(CANCEL);
 
   if (should_discard_pending_nav_entry_) {
     // Since no navigation happens we have to discard the transient entry
     // explicitely.  Note that by calling DiscardNonCommittedEntries() we also
     // discard the pending entry, which is what we want, since the navigation is
     // cancelled.
-    tab_->GetController().DiscardNonCommittedEntries();
+    web_contents_->GetController().DiscardNonCommittedEntries();
   }
 
   if (reload_on_dont_proceed_)
-    tab_->GetController().Reload(true);
+    web_contents_->GetController().Reload(true);
 
   Hide();
   delegate_->OnDontProceed();
   delete this;
 }
 
 void InterstitialPageImpl::CancelForNavigation() {
   // The user is trying to navigate away.  We should unblock the renderer and
   // disable the interstitial, but keep it visible until the navigation
   // completes.
@@ skipping 147 matching lines @@
 void InterstitialPageImpl::InterstitialPageRVHViewDelegate::UpdateDragCursor(
     WebDragOperation) {
   NOTREACHED() << "InterstitialPage does not support dragging yet.";
 }
 
 void InterstitialPageImpl::InterstitialPageRVHViewDelegate::GotFocus() {
 }
 
 void InterstitialPageImpl::InterstitialPageRVHViewDelegate::TakeFocus(
     bool reverse) {
-  if (!interstitial_page_->tab())
+  if (!interstitial_page_->web_contents())
     return;
-  TabContents* tab = static_cast<TabContents*>(interstitial_page_->tab());
-  if (!tab->GetViewDelegate())
+  WebContentsImpl* web_contents =
+      static_cast<WebContentsImpl*>(interstitial_page_->web_contents());
+  if (!web_contents->GetViewDelegate())
     return;
 
-  tab->GetViewDelegate()->TakeFocus(reverse);
+  web_contents->GetViewDelegate()->TakeFocus(reverse);
 }
 
 void InterstitialPageImpl::InterstitialPageRVHViewDelegate::OnFindReply(
     int request_id, int number_of_matches, const gfx::Rect& selection_rect,
     int active_match_ordinal, bool final_update) {
 }