Small fixes for Servicified SW code path

content/renderer/render_frame_impl.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/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 49 matching lines @@
 #include "content/common/download/mhtml_save_status.h"
 #include "content/common/edit_command.h"
 #include "content/common/frame_messages.h"
 #include "content/common/frame_owner_properties.h"
 #include "content/common/frame_replication_state.h"
 #include "content/common/input_messages.h"
 #include "content/common/navigation_params.h"
 #include "content/common/page_messages.h"
 #include "content/common/savable_subframe.h"
 #include "content/common/service_worker/service_worker_types.h"
+#include "content/common/service_worker/service_worker_utils.h"
 #include "content/common/site_isolation_policy.h"
 #include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_url_loader_factory_provider.mojom.h"
 #include "content/public/common/appcache_info.h"
 #include "content/public/common/associated_interface_provider.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_features.h"
@@ skipping 2831 matching lines @@
   worker_fetch_context->set_first_party_for_cookies(
       frame_->GetDocument().FirstPartyForCookies());
   worker_fetch_context->set_is_secure_context(
       frame_->GetDocument().IsSecureContext());
   blink::WebServiceWorkerNetworkProvider* web_provider =
       frame_->DataSource()->GetServiceWorkerNetworkProvider();
   if (web_provider) {
     ServiceWorkerNetworkProvider* provider =
         ServiceWorkerNetworkProvider::FromWebServiceWorkerNetworkProvider(
             web_provider);
+    if (!provider)
+      return nullptr;
     worker_fetch_context->set_service_worker_provider_id(
         provider->provider_id());
     worker_fetch_context->set_is_controlled_by_service_worker(
         provider->IsControlledByServiceWorker());
   }
   return std::move(worker_fetch_context);
 }
 
 WebExternalPopupMenu* RenderFrameImpl::CreateExternalPopupMenu(
     const WebPopupMenuInfo& popup_menu_info,
@@ skipping 30 matching lines @@
 }
 
 std::unique_ptr<blink::WebServiceWorkerProvider>
 RenderFrameImpl::CreateServiceWorkerProvider() {
   // At this point we should have non-null data source.
   DCHECK(frame_->DataSource());
   if (!ChildThreadImpl::current())
     return nullptr;  // May be null in some tests.
   ServiceWorkerNetworkProvider* provider =
       ServiceWorkerNetworkProvider::FromWebServiceWorkerNetworkProvider(
           frame_->DataSource()->GetServiceWorkerNetworkProvider());

[falken, 2017/06/12 01:10:36]

To make the two paths more clear, could this be better as:

if (!provider) {
  DCHECK(IsServicifcatinoEnabled());
  return nullptr;
}
if (!provider->context()) {
 // The context can be null when the frame is sandboxed.
  return nullptr;
}

[kinuko, 2017/06/12 02:16:51]

Done.

-  if (!provider->context()) {
+  if (!provider || !provider->context()) {
     // The context can be null when the frame is sandboxed.
     return nullptr;
   }
   return base::MakeUnique<WebServiceWorkerProviderImpl>(
       ChildThreadImpl::current()->thread_safe_sender(), provider->context());
 }
 
 service_manager::InterfaceProvider* RenderFrameImpl::GetInterfaceProvider() {
   DCHECK(remote_interfaces_);
   return remote_interfaces_.get();
@@ skipping 436 matching lines @@
         navigation_state->common_params().source_location->column_number;
     datasource->SetSourceLocation(source_location);
   }
 
   // Create the serviceworker's per-document network observing object if it
   // does not exist (When navigation happens within a page, the provider already
   // exists).
   if (datasource->GetServiceWorkerNetworkProvider())
     return;
 
+  if (ServiceWorkerUtils::IsServicificationEnabled()) {
+    // Disable interception via ServiceWorkerNetworkProvider if
+    // servicification is enabled.
+    return;
+  }
+
   datasource->SetServiceWorkerNetworkProvider(
       ServiceWorkerNetworkProvider::CreateForNavigation(
           routing_id_, navigation_state->request_params(), frame,
           content_initiated));
 }
 
 void RenderFrameImpl::DidStartProvisionalLoad(blink::WebDataSource* data_source,
                                               blink::WebURLRequest& request) {
   // In fast/loader/stop-provisional-loads.html, we abort the load before this
   // callback is invoked.
@@ skipping 3403 matching lines @@
       policy(info.default_policy),
       replaces_current_history_item(info.replaces_current_history_item),
       history_navigation_in_new_child_frame(
           info.is_history_navigation_in_new_child_frame),
       client_redirect(info.is_client_redirect),
       cache_disabled(info.is_cache_disabled),
       form(info.form),
       source_location(info.source_location) {}
 
 }  // namespace content