[Android WebView] Implement initial settings and callback support for Service Workers.

android_webview/browser/net/aw_request_interceptor.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 "android_webview/browser/net/aw_request_interceptor.h"
 
 #include <utility>
 
 #include "android_webview/browser/aw_contents_io_thread_client.h"
 #include "android_webview/browser/input_stream.h"
@@ skipping 96 matching lines @@
     }
   }
 
   scoped_ptr<AwContentsIoThreadClient> io_thread_client_;
   Callback callback_;
   base::WeakPtrFactory<ShouldInterceptRequestAdaptor> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ShouldInterceptRequestAdaptor);
 };
 
+scoped_ptr<AwContentsIoThreadClient> GetCorrespondingIoThreadClient(
+    net::URLRequest* request) {
+  int render_process_id, render_frame_id;
+  if (!content::ResourceRequestInfo::GetRenderFrameForRequest(
+          request, &render_process_id, &render_frame_id)) {
+       return AwContentsIoThreadClient::GetServiceWorkerIoThreadClient();

[mnaganov (inactive), 2016/01/12 00:42:03]

Are you sure it's safe to assume that if a corresponding RenderFrame isn't
found, the request is from a shared worker? How about dedicated web workers for
example? I don't think they have a RenderFrame.

[timvolodine, 2016/01/13 17:07:58]

Just checked: regular web workers do have a valid render frame id so the
callbacks should go the usual way to the webview client. And we don't expose
shared workers in webview, so this approach seems safe enough at this point.

Currently there doesn't seem to be a (straightforward and reliable) way to check
if the request originated from a service worker. Looks like it would require
changes to IPC structs to have this info reliably. Could probably be done as a
separate patch if we really need it..

[mnaganov (inactive), 2016/01/13 17:55:27]

OK, please then add a comment here explaining why we can assume that absence if
frame id means it's a request from SW.

[timvolodine, 2016/01/14 19:43:55]

Done.

+  }
+
+  scoped_ptr<AwContentsIoThreadClient> io_thread_client =
+      AwContentsIoThreadClient::FromID(render_process_id, render_frame_id);
+
+  if (!io_thread_client)
+    return AwContentsIoThreadClient::GetServiceWorkerIoThreadClient();
+
+  return io_thread_client;
+}
+
 }  // namespace
 
 AwRequestInterceptor::AwRequestInterceptor() {}
 
 AwRequestInterceptor::~AwRequestInterceptor() {}
 
 net::URLRequestJob* AwRequestInterceptor::MaybeInterceptRequest(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate) const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   // MaybeInterceptRequest can be called multiple times for the same request.
   if (request->GetUserData(kRequestAlreadyHasJobDataKey))
     return nullptr;
 
-  int render_process_id, render_frame_id;
-  if (!content::ResourceRequestInfo::GetRenderFrameForRequest(
-          request, &render_process_id, &render_frame_id)) {
-    return nullptr;
-  }
-
   scoped_ptr<AwContentsIoThreadClient> io_thread_client =
-      AwContentsIoThreadClient::FromID(render_process_id, render_frame_id);
+      GetCorrespondingIoThreadClient(request);
 
   if (!io_thread_client)
     return nullptr;
 
   GURL referrer(request->referrer());
   if (referrer.is_valid() &&
       (!request->is_pending() || request->is_redirecting())) {
     request->SetExtraRequestHeaderByName(net::HttpRequestHeaders::kReferer,
                                          referrer.spec(), true);
   }
   request->SetUserData(kRequestAlreadyHasJobDataKey,
                        new base::SupportsUserData::Data());
   return new AndroidStreamReaderURLRequestJob(
       request, network_delegate,
       make_scoped_ptr(
           new ShouldInterceptRequestAdaptor(std::move(io_thread_client))),
       true);
 }
 
 }  // namespace android_webview