Initialize RenderWidget(Host)(View)s with correct visibility state

content/browser/web_contents/render_view_host_manager.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/render_view_host_manager.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 56 matching lines @@
   for (RenderViewHostMap::iterator iter = swapped_out_hosts_.begin();
        iter != swapped_out_hosts_.end();
        ++iter) {
     iter->second->Shutdown();
   }
 }
 
 void RenderViewHostManager::Init(BrowserContext* browser_context,
                                  SiteInstance* site_instance,
                                  int routing_id,
-                                 int main_frame_routing_id) {
+                                 int main_frame_routing_id,
+                                 bool hidden) {
   // Create a RenderViewHost, once we have an instance.  It is important to
   // immediately give this SiteInstance to a RenderViewHost so that it is
   // ref counted.
   if (!site_instance)
     site_instance = SiteInstance::Create(browser_context);
   render_view_host_ = static_cast<RenderViewHostImpl*>(
       RenderViewHostFactory::Create(
           site_instance, render_view_delegate_, render_widget_delegate_,
-          routing_id, main_frame_routing_id, false));
+          routing_id, main_frame_routing_id, false, hidden));
 
   // Keep track of renderer processes as they start to shut down or are
   // crashed/killed.
   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSED,
                  NotificationService::AllSources());
   registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CLOSING,
                  NotificationService::AllSources());
 }
 
 RenderViewHostImpl* RenderViewHostManager::current_host() const {
@@ skipping 23 matching lines @@
   // potential privilege escalation.
   if (pending_web_ui_.get() &&
       entry.bindings() != NavigationEntryImpl::kInvalidBindings &&
       pending_web_ui_->GetBindings() != entry.bindings()) {
     RecordAction(UserMetricsAction("ProcessSwapBindingsMismatch_RVHM"));
     pending_web_ui_.reset();
   }
 }
 
 RenderViewHostImpl* RenderViewHostManager::Navigate(
-    const NavigationEntryImpl& entry) {
+    const NavigationEntryImpl& entry, bool hidden) {
   TRACE_EVENT0("browser", "RenderViewHostManager:Navigate");
   // Create a pending RenderViewHost. It will give us the one we should use
   RenderViewHostImpl* dest_render_view_host =
-      static_cast<RenderViewHostImpl*>(UpdateRendererStateForNavigate(entry));
+      static_cast<RenderViewHostImpl*>(
+          UpdateRendererStateForNavigate(entry, hidden));
   if (!dest_render_view_host)
     return NULL;  // We weren't able to create a pending render view host.
 
   // If the current render_view_host_ isn't live, we should create it so
   // that we don't show a sad tab while the dest_render_view_host fetches
   // its first page.  (Bug 1145340)
   if (dest_render_view_host != render_view_host_ &&
       !render_view_host_->IsRenderViewLive()) {
     // Note: we don't call InitRenderView here because we are navigating away
     // soon anyway, and we don't have the NavigationEntry for this host.
@@ skipping 490 matching lines @@
     // SiteInstance to a RenderViewHost (if it is different than our current
     // SiteInstance), so that it is ref counted.  This will happen in
     // CreateRenderView.
     return curr_instance->GetRelatedSiteInstance(dest_url);
   }
 }
 
 int RenderViewHostManager::CreateRenderView(
     SiteInstance* instance,
     int opener_route_id,
-    bool swapped_out) {
+    bool swapped_out,
+    bool hidden) {

[Charlie Reis, 2013/08/19 22:18:02]

Can we add a DCHECK that swapped_out implies hidden?  I'd love to catch any bugs
where swapped out RenderViewHosts are being considered visible.

[jamesr, 2013/08/19 23:50:39]

Done.

   CHECK(instance);
 
   // Check if we've already created an RVH for this SiteInstance.  If so, try
   // to re-use the existing one, which has already been initialized.  We'll
   // remove it from the list of swapped out hosts if it commits.
   RenderViewHostImpl* new_render_view_host = static_cast<RenderViewHostImpl*>(
       GetSwappedOutRenderViewHost(instance));
   if (new_render_view_host) {
     // Prevent the process from exiting while we're trying to use it.
     if (!swapped_out)
       new_render_view_host->GetProcess()->AddPendingView();
   } else {
     // Create a new RenderViewHost if we don't find an existing one.
     new_render_view_host = static_cast<RenderViewHostImpl*>(
         RenderViewHostFactory::Create(instance,
                                       render_view_delegate_,
                                       render_widget_delegate_,
                                       MSG_ROUTING_NONE,
                                       MSG_ROUTING_NONE,
-                                      swapped_out));
+                                      swapped_out,
+                                      hidden));
 
     // If the new RVH is swapped out already, store it.  Otherwise prevent the
     // process from exiting while we're trying to navigate in it.
     if (swapped_out) {
       swapped_out_hosts_[instance->GetId()] = new_render_view_host;
     } else {
       new_render_view_host->GetProcess()->AddPendingView();
     }
 
     bool success = InitRenderView(new_render_view_host, opener_route_id);
@@ skipping 163 matching lines @@
     }
   }
 
   // Finally we delete the gathered RVHs, which should not indirectly
   // delete each other.
   for (size_t i = 0; i < rvhs_to_be_deleted.size(); ++i)
     rvhs_to_be_deleted[i]->Shutdown();
 }
 
 RenderViewHostImpl* RenderViewHostManager::UpdateRendererStateForNavigate(
-    const NavigationEntryImpl& entry) {
+    const NavigationEntryImpl& entry, bool hidden) {
   // If we are cross-navigating, then we want to get back to normal and navigate
   // as usual.
   if (cross_navigation_pending_) {
     if (pending_render_view_host_)
       CancelPending();
     cross_navigation_pending_ = false;
   }
 
   // render_view_host_ will not be deleted before the end of this method, so we
   // don't have to worry about this SiteInstance's ref count dropping to zero.
@@ skipping 27 matching lines @@
     // we are staying in the same BrowsingInstance. This allows the pending RVH
     // to send cross-process script calls to its opener(s).
     int opener_route_id = MSG_ROUTING_NONE;
     if (new_instance->IsRelatedSiteInstance(curr_instance)) {
       opener_route_id =
           delegate_->CreateOpenerRenderViewsForRenderManager(new_instance);
     }
 
     // Create a non-swapped-out pending RVH with the given opener and navigate
     // it.
-    int route_id = CreateRenderView(new_instance, opener_route_id, false);
+    int route_id = CreateRenderView(new_instance,
+                                    opener_route_id,
+                                    false,
+                                    hidden);

[Charlie Reis, 2013/08/19 22:18:02]

Style nit: No need for one param-per-line on function calls, just on function
declarations.

[jamesr, 2013/08/19 23:50:39]

Hmm.  We're inconsistent on this, but sure.

     if (route_id == MSG_ROUTING_NONE)
       return NULL;
 
     // Check if our current RVH is live before we set up a transition.
     if (!render_view_host_->IsRenderViewLive()) {
       if (!cross_navigation_pending_) {
         // The current RVH is not live.  There's no reason to sit around with a
         // sad tab or a newly created RVH while we wait for the pending RVH to
         // navigate.  Just switch to the pending RVH now and go back to non
         // cross-navigating (Note that we don't care about on{before}unload
@@ skipping 145 matching lines @@
 RenderViewHostImpl* RenderViewHostManager::GetSwappedOutRenderViewHost(
     SiteInstance* instance) {
   RenderViewHostMap::iterator iter = swapped_out_hosts_.find(instance->GetId());
   if (iter != swapped_out_hosts_.end())
     return iter->second;
 
   return NULL;
 }
 
 }  // namespace content