Tease apart ServiceWorkerNetworkProvider from other stuff.

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 "base/command_line.h"
 #include "base/debug/alias.h"
 #include "base/debug/dump_without_crashing.h"
 #include "base/i18n/char_iterator.h"
 #include "base/metrics/histogram.h"
 #include "base/process/kill.h"
 #include "base/process/process.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/child/appcache/appcache_dispatcher.h"
 #include "content/child/plugin_messages.h"
 #include "content/child/quota_dispatcher.h"
 #include "content/child/request_extra_data.h"
+#include "content/child/service_worker/service_worker_network_provider.h"
 #include "content/child/service_worker/web_service_worker_provider_impl.h"
 #include "content/common/frame_messages.h"
+#include "content/common/service_worker/service_worker_types.h"
 #include "content/common/socket_stream_handle_data.h"
 #include "content/common/swapped_out_messages.h"
 #include "content/common/view_messages.h"
 #include "content/public/common/bindings_policy.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/context_menu_params.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/common/url_utils.h"
 #include "content/public/renderer/content_renderer_client.h"
@@ skipping 1136 matching lines @@
                                           blink::WebDataSource* datasource) {
   DCHECK(!frame_ || frame_ == frame);
 
   // TODO(nasko): Move implementation here. Needed state:
   // * pending_navigation_params_
   // * webview
   // Needed methods:
   // * PopulateDocumentStateFromPending
   // * CreateNavigationStateFromPending
   render_view_->didCreateDataSource(frame, datasource);
+
+  // Create the serviceworker's per-document network observing object.
+  scoped_ptr<ServiceWorkerNetworkProvider>
+      network_provider(new ServiceWorkerNetworkProvider());
+  ServiceWorkerNetworkProvider::AttachToDocumentState(
+      DocumentState::FromDataSource(datasource),
+      network_provider.Pass());
 }
 
 void RenderFrameImpl::didStartProvisionalLoad(blink::WebFrame* frame) {
   DCHECK(!frame_ || frame_ == frame);
   WebDataSource* ds = frame->provisionalDataSource();
 
   // In fast/loader/stop-provisional-loads.html, we abort the load before this
   // callback is invoked.
   if (!ds)
     return;
@@ skipping 536 matching lines @@
     should_replace_current_entry = data_source->replacesCurrentHistoryItem();
   } else {
     // If the navigation is browser-initiated, the NavigationState contains the
     // correct value instead of the WebDataSource.
     //
     // TODO(davidben): Avoid this awkward duplication of state. See comment on
     // NavigationState::should_replace_current_entry().
     should_replace_current_entry =
         navigation_state->should_replace_current_entry();
   }
+
+  // TODO(michaeln): Add WebDataSource* as a param to willSendRequest so
+  // this ambiguity about which datasource can be removed.
+  int provider_id = kInvalidServiceWorkerProviderId;
+  if (request.targetType() == blink::WebURLRequest::TargetIsMainFrame ||
+      request.targetType() == blink::WebURLRequest::TargetIsSubframe) {
+    if (frame->provisionalDataSource()) {  // May be null is some tests.

[michaeln, 2014/03/04 00:13:55]

The ResourceFetcher tests all do this,
  fetcher->Start(frame, WebURLRequest::TargetIsMainFrame,...
so this logic see 'mainframe' but its not really so.

+      ServiceWorkerNetworkProvider* provider =
+          ServiceWorkerNetworkProvider::FromDocumentState(
+              DocumentState::FromDataSource(frame->provisionalDataSource()));
+      provider_id = provider->provider_id();
+    }
+  } else if (frame->dataSource()) {
+    ServiceWorkerNetworkProvider* provider =
+        ServiceWorkerNetworkProvider::FromDocumentState(
+            DocumentState::FromDataSource(frame->dataSource()));
+    provider_id = provider->provider_id();
+  }
+
   // TODO(creis): Remove the second routing ID from the request, now that we
   // use routing IDs instead of frame IDs.  (This is a viral change, so I'm
   // splitting it into multiple CLs.)
   int parent_routing_id = frame->parent() ?
       FromWebFrame(frame->parent())->GetRoutingID() : -1;
   request.setExtraData(
       new RequestExtraData(render_view_->visibilityState(),
                            custom_user_agent,
                            was_after_preconnect_request,
                            routing_id_,
                            (frame == top_frame),
                            routing_id_,
                            GURL(frame->document().securityOrigin().toString()),
                            frame->parent() == top_frame,
                            parent_routing_id,
                            navigation_state->allow_download(),
                            transition_type,
                            should_replace_current_entry,
                            navigation_state->transferred_request_child_id(),
-                           navigation_state->transferred_request_request_id()));
+                           navigation_state->transferred_request_request_id(),
+                           provider_id));
 
   DocumentState* top_document_state =
       DocumentState::FromDataSource(top_data_source);
   if (top_document_state) {
     // TODO(gavinp): separate out prefetching and prerender field trials
     // if the rel=prerender rel type is sticking around.
     if (request.targetType() == WebURLRequest::TargetIsPrefetch)
       top_document_state->set_was_prefetcher(true);
 
     if (was_after_preconnect_request)
@@ skipping 509 matching lines @@
 
 void RenderFrameImpl::didStartLoading() {
   Send(new FrameHostMsg_DidStartLoading(routing_id_));
 }
 
 void RenderFrameImpl::didStopLoading() {
   Send(new FrameHostMsg_DidStopLoading(routing_id_));
 }
 
 }  // namespace content