TabContents -> WebContentsImpl, part 12.

content/browser/web_contents/web_contents_view_helper.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_view_helper.h"
 
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/web_contents/web_contents_impl.h"
 #include "content/common/view_messages.h"
 #include "content/port/browser/render_widget_host_view_port.h"
@@ skipping 28 matching lines @@
   RenderWidgetHost* host = content::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;
     }
   }
 }
 
-TabContents* WebContentsViewHelper::CreateNewWindow(
+WebContentsImpl* WebContentsViewHelper::CreateNewWindow(
     WebContents* web_contents,
     int route_id,
     const ViewHostMsg_CreateWindow_Params& params) {
   bool should_create = true;
   if (web_contents->GetDelegate()) {
     should_create = web_contents->GetDelegate()->ShouldCreateWebContents(
         web_contents,
         route_id,
         params.window_container_type,
         params.frame_name,
         params.target_url);
   }
 
   if (!should_create)
     return NULL;
 
   // We usually create the new window in the same BrowsingInstance (group of
   // script-related windows), by passing in the current SiteInstance.  However,
   // if the opener is being suppressed, we create a new SiteInstance in its own
   // BrowsingInstance.
   scoped_refptr<content::SiteInstance> site_instance =
       params.opener_suppressed ?
       content::SiteInstance::Create(web_contents->GetBrowserContext()) :
       web_contents->GetSiteInstance();
 
   // Create the new web contents. This will automatically create the new
   // WebContentsView. In the future, we may want to create the view separately.
-  TabContents* new_contents =
-      new TabContents(web_contents->GetBrowserContext(),
-                      site_instance,
-                      route_id,
-                      static_cast<TabContents*>(web_contents),
-                      NULL);
+  WebContentsImpl* new_contents =
+      new WebContentsImpl(web_contents->GetBrowserContext(),
+                          site_instance,
+                          route_id,
+                          static_cast<WebContentsImpl*>(web_contents),
+                          NULL);
   new_contents->set_opener_web_ui_type(
       web_contents->GetWebUITypeForCurrentState());
   new_contents->set_has_opener(!params.opener_url.is_empty());
 
   if (!params.opener_suppressed) {
     content::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());
@@ skipping 41 matching lines @@
       RenderWidgetHostViewPort::CreateViewForWidget(widget_host);
   if (!is_fullscreen) {
     // Popups should not get activated.
     widget_view->SetPopupType(popup_type);
   }
   // Save the created widget associated with the route so we can show it later.
   pending_widget_views_[route_id] = widget_view;
   return widget_view;
 }
 
-TabContents* WebContentsViewHelper::GetCreatedWindow(int route_id) {
+WebContentsImpl* WebContentsViewHelper::GetCreatedWindow(int route_id) {
   PendingContents::iterator iter = pending_contents_.find(route_id);
 
   // Certain systems can block the creation of new windows. If we didn't succeed
   // in creating one, just return NULL.
   if (iter == pending_contents_.end()) {
     return NULL;
   }
 
-  TabContents* new_contents = iter->second;
+  WebContentsImpl* new_contents = iter->second;
   pending_contents_.erase(route_id);
 
   if (!new_contents->GetRenderProcessHost()->HasConnection() ||
       !new_contents->GetRenderViewHost()->GetView())
     return NULL;
 
   // TODO(brettw): It seems bogus to reach into here and initialize the host.
   static_cast<RenderViewHostImpl*>(new_contents->GetRenderViewHost())->Init();
   return new_contents;
 }
@@ skipping 10 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;
 }
 
-TabContents* WebContentsViewHelper::ShowCreatedWindow(
+WebContentsImpl* WebContentsViewHelper::ShowCreatedWindow(
     WebContents* web_contents,
     int route_id,
     WindowOpenDisposition disposition,
     const gfx::Rect& initial_pos,
     bool user_gesture) {
-  TabContents* contents = GetCreatedWindow(route_id);
+  WebContentsImpl* contents = GetCreatedWindow(route_id);
   if (contents) {
     web_contents->AddNewContents(contents,
                                  disposition,
                                  initial_pos,
                                  user_gesture);
   }
   return contents;
 }
 
 RenderWidgetHostView* WebContentsViewHelper::ShowCreatedWidget(
     WebContents* web_contents,
     int route_id,
     bool is_fullscreen,
     const gfx::Rect& initial_pos) {
   if (web_contents->GetDelegate())
     web_contents->GetDelegate()->RenderWidgetShowing();
 
   RenderWidgetHostViewPort* widget_host_view =
       RenderWidgetHostViewPort::FromRWHV(GetCreatedWidget(route_id));
   if (is_fullscreen) {
     widget_host_view->InitAsFullscreen(web_contents->GetRenderWidgetHostView());
   } else {
     widget_host_view->InitAsPopup(web_contents->GetRenderWidgetHostView(),
                                   initial_pos);
   }
   RenderWidgetHostImpl::From(widget_host_view->GetRenderWidgetHost())->Init();
   return widget_host_view;
 }