Move existing kSitePerProcess checks to a policy-oracle object

content/browser/frame_host/render_frame_host_manager.cc

 // Copyright 2013 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/frame_host/render_frame_host_manager.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/command_line.h"
@@ skipping 13 matching lines @@
 #include "content/browser/frame_host/render_frame_host_factory.h"
 #include "content/browser/frame_host/render_frame_host_impl.h"
 #include "content/browser/frame_host/render_frame_proxy_host.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/renderer_host/render_view_host_factory.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/browser/site_instance_impl.h"
 #include "content/browser/webui/web_ui_controller_factory_registry.h"
 #include "content/browser/webui/web_ui_impl.h"
 #include "content/common/frame_messages.h"
+#include "content/common/site_isolation_policy.h"
 #include "content/common/view_messages.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host_observer.h"
 #include "content/public/browser/render_widget_host_iterator.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_ui_controller.h"
+#include "content/public/common/browser_plugin_guest_mode.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/referrer.h"
 #include "content/public/common/url_constants.h"
 
 namespace content {
 
 // A helper class to hold all frame proxies and register as a
 // RenderProcessHostObserver for them.
 class RenderFrameHostManager::RenderFrameProxyHostMap
     : public RenderProcessHostObserver {
@@ skipping 110 matching lines @@
 }
 
 // static
 bool RenderFrameHostManager::ClearRFHsPendingShutdown(FrameTreeNode* node) {
   node->render_manager()->pending_delete_hosts_.clear();
   return true;
 }
 
 // static
 bool RenderFrameHostManager::IsSwappedOutStateForbidden() {
-  return base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kSitePerProcess);
+  return SiteIsolationPolicy::AreCrossProcessFramesPossible();
 }
 
 RenderFrameHostManager::RenderFrameHostManager(
     FrameTreeNode* frame_tree_node,
     RenderFrameHostDelegate* render_frame_delegate,
     RenderViewHostDelegate* render_view_delegate,
     RenderWidgetHostDelegate* render_widget_delegate,
     Delegate* delegate)
     : frame_tree_node_(frame_tree_node),
       delegate_(delegate),
@@ skipping 718 matching lines @@
   // swap are sent to the browser via the OpenURL IPC and are afterwards treated
   // as browser-initiated navigations. NavigationRequests marked as
   // renderer-initiated are created by receiving a BeginNavigation IPC, and will
   // then proceed in the same renderer that sent the IPC due to the condition
   // below.
   // Subframe navigations will use the current renderer, unless
   // --site-per-process is enabled.
   // TODO(carlosk): Have renderer-initated main frame navigations swap processes
   // if needed when it no longer breaks OAuth popups (see
   // https://crbug.com/440266).
-  bool site_per_process = base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kSitePerProcess);
   bool is_main_frame = frame_tree_node_->IsMainFrame();
   if (current_site_instance == dest_site_instance.get() ||
       (!request.browser_initiated() && is_main_frame) ||
-      (!is_main_frame && !site_per_process)) {
+      (!is_main_frame && !dest_site_instance->RequiresDedicatedProcess() &&
+       !current_site_instance->RequiresDedicatedProcess())) {
     // Reuse the current RFH if its SiteInstance matches the the navigation's
     // or if this is a subframe navigation. We only swap RFHs for subframes when
     // --site-per-process is enabled.
     CleanUpNavigation();
     navigation_rfh = render_frame_host_.get();
 
     // As SiteInstances are the same, check if the WebUI should be reused.
     const NavigationEntry* current_navigation_entry =
         delegate_->GetLastCommittedNavigationEntryForRenderManager();
     should_reuse_web_ui_ = ShouldReuseWebUI(current_navigation_entry,
@@ skipping 92 matching lines @@
 void RenderFrameHostManager::OnDidStopLoading() {
   for (const auto& pair : *proxy_hosts_) {
     pair.second->Send(new FrameMsg_DidStopLoading(pair.second->GetRoutingID()));
   }
 }
 
 void RenderFrameHostManager::OnDidUpdateName(const std::string& name) {
   // The window.name message may be sent outside of --site-per-process when
   // report_frame_name_changes renderer preference is set (used by
   // WebView).  Don't send the update to proxies in those cases.
-  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSitePerProcess))
+  // TODO(nick,nasko): Should this be IsSwappedOutStateForbidden, to match
+  // OnDidUpdateOrigin?
+  if (!SiteIsolationPolicy::AreCrossProcessFramesPossible())
     return;
 
   for (const auto& pair : *proxy_hosts_) {
     pair.second->Send(
         new FrameMsg_DidUpdateName(pair.second->GetRoutingID(), name));
   }
 }
 
 void RenderFrameHostManager::OnDidUpdateOrigin(const url::Origin& origin) {
   if (!IsSwappedOutStateForbidden())
@@ skipping 44 matching lines @@
                                                         FrameTreeNode* node) {
   RenderFrameProxyHost* proxy =
       node->render_manager()->proxy_hosts_->Get(site_instance_id);
   if (proxy)
     proxy->set_render_frame_proxy_created(false);
 
   return true;
 }
 
 bool RenderFrameHostManager::ShouldTransitionCrossSite() {
-  // True for --site-per-process, which overrides both kSingleProcess and
-  // kProcessPerTab.
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSitePerProcess))
+  // The logic below is weaker than "are all sites isolated" -- it asks instead,
+  // "is any site isolated". That's appropriate here since we're just trying to
+  // figure out if we're in any kind of site isolated mode, and in which case,
+  // we ignore the kSingleProcess and kProcessPerTab settings.
+  //
+  // TODO(nick): Move all handling of kSingleProcess/kProcessPerTab into
+  // SiteIsolationPolicy so we have a consistent behavior around the interaction
+  // of the process model flags.
+  if (SiteIsolationPolicy::AreCrossProcessFramesPossible())
     return true;
 
   // False in the single-process mode, as it makes RVHs to accumulate
   // in swapped_out_hosts_.
   // True if we are using process-per-site-instance (default) or
   // process-per-site (kProcessPerSite).
+  // TODO(nick): Move handling of kSingleProcess and kProcessPerTab into
+  // SiteIsolationPolicy.
   return !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kSingleProcess) &&
          !base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kProcessPerTab);
 }
 
 bool RenderFrameHostManager::ShouldSwapBrowsingInstancesForNavigation(
     const GURL& current_effective_url,
     bool current_is_view_source_mode,
     SiteInstance* new_site_instance,
@@ skipping 324 matching lines @@
 
 const GURL& RenderFrameHostManager::GetCurrentURLForSiteInstance(
     SiteInstance* current_instance, NavigationEntry* current_entry) {
   // If this is a subframe that is potentially out of process from its parent,
   // don't consider using current_entry's url for SiteInstance selection, since
   // current_entry's url is for the main frame and may be in a different site
   // than this frame.
   // TODO(creis): Remove this when we can check the FrameNavigationEntry's url.
   // See http://crbug.com/369654
   if (!frame_tree_node_->IsMainFrame() &&
-      base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSitePerProcess))
+      SiteIsolationPolicy::AreCrossProcessFramesPossible())
     return frame_tree_node_->current_url();
 
   // If there is no last non-interstitial entry (and current_instance already
   // has a site), then we must have been opened from another tab.  We want
   // to compare against the URL of the page that opened us, but we can't
   // get to it directly.  The best we can do is check against the site of
   // the SiteInstance.  This will be correct when we intercept links and
   // script-based navigations, but for now, it could place some pages in a
   // new process unnecessarily.  We should only hit this case if a page tries
   // to open a new tab to an interstitial-inducing URL, and then navigates
@@ skipping 33 matching lines @@
       new_instance, pending_web_ui(), create_render_frame_flags, nullptr);
 }
 
 void RenderFrameHostManager::CreateProxiesForNewRenderFrameHost(
     SiteInstance* old_instance,
     SiteInstance* new_instance,
     int* create_render_frame_flags) {
   // Only create opener proxies if they are in the same BrowsingInstance.
   if (new_instance->IsRelatedSiteInstance(old_instance))
     CreateOpenerProxiesIfNeeded(new_instance);
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSitePerProcess)) {
+  if (SiteIsolationPolicy::AreCrossProcessFramesPossible()) {
     // Ensure that the frame tree has RenderFrameProxyHosts for the new
     // SiteInstance in all nodes except the current one.  We do this for all
     // frames in the tree, whether they are in the same BrowsingInstance or not.
     // We will still check whether two frames are in the same BrowsingInstance
     // before we allow them to interact (e.g., postMessage).
     frame_tree_node_->frame_tree()->CreateProxiesForSiteInstance(
         frame_tree_node_, new_instance);
     // RenderFrames in different processes from their parent RenderFrames
     // in the frame tree require RenderWidgets for rendering and processing
     // input events.
     if (frame_tree_node_->parent() &&
         frame_tree_node_->parent()->current_frame_host()->GetSiteInstance() !=
             new_instance)
       *create_render_frame_flags |= CREATE_RF_NEEDS_RENDER_WIDGET_HOST;
   }
 }
 
 void RenderFrameHostManager::CreateProxiesForNewNamedFrame() {
-  // TODO(alexmos): use SiteIsolationPolicy::AreCrossProcessFramesPossible once
-  // https://codereview.chromium.org/1208143002/ lands.
-  if (!base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSitePerProcess))
+  if (!SiteIsolationPolicy::AreCrossProcessFramesPossible())
     return;
 
   DCHECK(!frame_tree_node_->frame_name().empty());
 
   // If this is a top-level frame, create proxies for this node in the
   // SiteInstances of its opener's ancestors, which are allowed to discover
   // this frame by name (see https://crbug.com/511474 and part 4 of
   // https://html.spec.whatwg.org/#the-rules-for-choosing-a-browsing-context-
   // given-a-browsing-context-name).
   FrameTreeNode* opener = frame_tree_node_->opener();
@@ skipping 86 matching lines @@
   return true;
 }
 
 scoped_ptr<RenderFrameHostImpl> RenderFrameHostManager::CreateRenderFrame(
     SiteInstance* instance,
     WebUIImpl* web_ui,
     int flags,
     int* view_routing_id_ptr) {
   bool swapped_out = !!(flags & CREATE_RF_SWAPPED_OUT);
   bool swapped_out_forbidden = IsSwappedOutStateForbidden();
-  bool is_site_per_process = base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kSitePerProcess);
 
   CHECK(instance);
   CHECK_IMPLIES(swapped_out_forbidden, !swapped_out);
-  CHECK_IMPLIES(!is_site_per_process, frame_tree_node_->IsMainFrame());
+  CHECK_IMPLIES(!SiteIsolationPolicy::AreCrossProcessFramesPossible(),
+                frame_tree_node_->IsMainFrame());
 
   // Swapped out views should always be hidden.
   DCHECK_IMPLIES(swapped_out, (flags & CREATE_RF_HIDDEN));
 
   scoped_ptr<RenderFrameHostImpl> new_render_frame_host;
   bool success = true;
   if (view_routing_id_ptr)
     *view_routing_id_ptr = MSG_ROUTING_NONE;
 
   // We are creating a pending, speculative or swapped out RFH here. We should
@@ skipping 157 matching lines @@
   if (!proxy)
     return;
 
   InitRenderView(render_view_host, proxy->GetRoutingID(), false);
   proxy->set_render_frame_proxy_created(true);
 }
 
 void RenderFrameHostManager::CreateOuterDelegateProxy(
     SiteInstance* outer_contents_site_instance,
     RenderFrameHostImpl* render_frame_host) {
-  CHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
-      switches::kSitePerProcess));
+  CHECK(BrowserPluginGuestMode::UseCrossProcessFramesForGuests());
   RenderFrameProxyHost* proxy = new RenderFrameProxyHost(
       outer_contents_site_instance, nullptr, frame_tree_node_);
   proxy_hosts_->Add(outer_contents_site_instance->GetId(),
                     make_scoped_ptr(proxy));
 
   // Swap the outer WebContents's frame with the proxy to inner WebContents.
   //
   // We are in the outer WebContents, and its FrameTree would never see
   // a load start for any of its inner WebContents. Eventually, that also makes
   // the FrameTree never see the matching load stop. Therefore, we always pass
@@ skipping 249 matching lines @@
   // In the --site-per-process case, old subframe RFHs are not kept alive inside
   // the proxy.
   SwapOutOldFrame(old_render_frame_host.Pass());
 
   if (RenderFrameHostManager::IsSwappedOutStateForbidden()) {
     // Since the new RenderFrameHost is now committed, there must be no proxies
     // for its SiteInstance. Delete any existing ones.
     proxy_hosts_->Remove(render_frame_host_->GetSiteInstance()->GetId());
   }
 
-  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSitePerProcess)) {
-    // If this is a subframe, it should have a CrossProcessFrameConnector
-    // created already.  Use it to link the new RFH's view to the proxy that
-    // belongs to the parent frame's SiteInstance. If this navigation causes
-    // an out-of-process frame to return to the same process as its parent, the
-    // proxy would have been removed from proxy_hosts_ above.
-    // Note: We do this after swapping out the old RFH because that may create
-    // the proxy we're looking for.
-    RenderFrameProxyHost* proxy_to_parent = GetProxyToParent();
-    if (proxy_to_parent)
-      proxy_to_parent->SetChildRWHView(render_frame_host_->GetView());
+  // If this is a subframe, it should have a CrossProcessFrameConnector
+  // created already.  Use it to link the new RFH's view to the proxy that
+  // belongs to the parent frame's SiteInstance. If this navigation causes
+  // an out-of-process frame to return to the same process as its parent, the
+  // proxy would have been removed from proxy_hosts_ above.
+  // Note: We do this after swapping out the old RFH because that may create
+  // the proxy we're looking for.
+  RenderFrameProxyHost* proxy_to_parent = GetProxyToParent();
+  if (proxy_to_parent) {
+    CHECK(SiteIsolationPolicy::AreCrossProcessFramesPossible());
+    proxy_to_parent->SetChildRWHView(render_frame_host_->GetView());
   }
 
   // After all is done, there must never be a proxy in the list which has the
   // same SiteInstance as the current RenderFrameHost.
   CHECK(!proxy_hosts_->Get(render_frame_host_->GetSiteInstance()->GetId()));
 }
 
 void RenderFrameHostManager::ShutdownProxiesIfLastActiveFrameInSiteInstance(
     RenderFrameHostImpl* render_frame_host) {
   if (!render_frame_host)
@@ skipping 39 matching lines @@
     SiteInstance* source_instance,
     SiteInstance* dest_instance,
     ui::PageTransition transition,
     bool dest_is_restore,
     bool dest_is_view_source_mode,
     const GlobalRequestID& transferred_request_id,
     int bindings) {
   // Don't swap for subframes unless we are in --site-per-process.  We can get
   // here in tests for subframes (e.g., NavigateFrameToURL).
   if (!frame_tree_node_->IsMainFrame() &&
-      !base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kSitePerProcess))
+      !SiteIsolationPolicy::AreCrossProcessFramesPossible()) {
     return render_frame_host_.get();
+  }
 
   // If we are currently navigating cross-process, we want to get back to normal
   // and then navigate as usual.
   if (pending_render_frame_host_)
     CancelPending();
 
   SiteInstance* current_instance = render_frame_host_->GetSiteInstance();
   scoped_refptr<SiteInstance> new_instance = GetSiteInstanceForNavigation(
       dest_url, source_instance, dest_instance, nullptr, transition,
       dest_is_restore, dest_is_view_source_mode);
@@ skipping 264 matching lines @@
 int RenderFrameHostManager::GetOpenerRoutingID(SiteInstance* instance) {
   if (!frame_tree_node_->opener())
     return MSG_ROUTING_NONE;
 
   return frame_tree_node_->opener()
       ->render_manager()
       ->GetRoutingIdForSiteInstance(instance);
 }
 
 }  // namespace content