[android_webview] Don't intercept resource and asset URLRequests.

android_webview/browser/net/aw_url_request_context_getter.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_url_request_context_getter.h"
 
+#include <vector>
+
 #include "android_webview/browser/aw_browser_context.h"
 #include "android_webview/browser/aw_request_interceptor.h"
 #include "android_webview/browser/net/aw_network_delegate.h"
 #include "android_webview/browser/net/aw_url_request_job_factory.h"
 #include "android_webview/browser/net/init_native_callback.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/url_constants.h"
 #include "net/http/http_cache.h"
@@ skipping 48 matching lines @@
   PopulateNetworkSessionParams(&network_session_params);
   net::HttpCache* main_cache = new net::HttpCache(
       network_session_params,
       new net::HttpCache::DefaultBackend(
           net::DISK_CACHE,
           browser_context_->GetPath().Append(FILE_PATH_LITERAL("Cache")),
           10 * 1024 * 1024,  // 10M
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)));
   main_http_factory_.reset(main_cache);
   url_request_context_->set_http_transaction_factory(main_cache);
+
+  CreateCookieMonster(url_request_context_.get());

[boliu, 2013/03/01 18:44:11]

This bit is already fixed in https://codereview.chromium.org/12387028/

[mkosiba (inactive), 2013/03/05 16:34:43]

Ok, looks like I need to rebase.

 }
 
 void AwURLRequestContextGetter::PopulateNetworkSessionParams(
     net::HttpNetworkSession::Params* params) {
   net::URLRequestContext* context = url_request_context_.get();
   params->host_resolver = context->host_resolver();
   params->cert_verifier = context->cert_verifier();
   params->server_bound_cert_service = context->server_bound_cert_service();
   params->transport_security_state = context->transport_security_state();
   params->proxy_service = context->proxy_service();
   params->ssl_config_service = context->ssl_config_service();
   params->http_auth_handler_factory = context->http_auth_handler_factory();
   params->network_delegate = context->network_delegate();
   params->http_server_properties = context->http_server_properties();
   params->net_log = context->net_log();
 }
 
+namespace {
+
+typedef std::vector<net::URLRequestJobFactory::ProtocolHandler*>
+    ProtocolHandlerVector;
+
+scoped_ptr<net::URLRequestJobFactory> WrapFactoryWithProtocolHandlers(
+    scoped_ptr<net::URLRequestJobFactory> job_factory,
+    const ProtocolHandlerVector& protocol_handlers) {
+  // The chain of responsibility is constructed in reverse of the order in
+  // which we want the particular protocol handlers invoked.
+  for (ProtocolHandlerVector::const_reverse_iterator
+           i = protocol_handlers.rbegin();
+       i != protocol_handlers.rend();
+       ++i) {
+    job_factory.reset(new net::ProtocolInterceptJobFactory(
+        job_factory.Pass(), make_scoped_ptr(*i)));
+  }
+  return job_factory.Pass();
+}
+
+} // namespace
+
 net::URLRequestContext* AwURLRequestContextGetter::GetURLRequestContext() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   if (!job_factory_) {
     scoped_ptr<AwURLRequestJobFactory> job_factory(new AwURLRequestJobFactory);
     bool set_protocol = job_factory->SetProtocolHandler(
         chrome::kFileScheme, new net::FileProtocolHandler());
     DCHECK(set_protocol);
     set_protocol = job_factory->SetProtocolHandler(
         chrome::kDataScheme, new net::DataProtocolHandler());
     DCHECK(set_protocol);
     DCHECK(blob_protocol_handler_);
     set_protocol = job_factory->SetProtocolHandler(
         chrome::kBlobScheme, blob_protocol_handler_.release());
     DCHECK(set_protocol);
     DCHECK(file_system_protocol_handler_);
     set_protocol = job_factory->SetProtocolHandler(
         chrome::kFileSystemScheme, file_system_protocol_handler_.release());
     DCHECK(set_protocol);
     DCHECK(chrome_protocol_handler_);
     set_protocol = job_factory->SetProtocolHandler(
         chrome::kChromeUIScheme, chrome_protocol_handler_.release());
     DCHECK(set_protocol);
     DCHECK(chrome_devtools_protocol_handler_);
     set_protocol = job_factory->SetProtocolHandler(
         chrome::kChromeDevToolsScheme,
         chrome_devtools_protocol_handler_.release());
     DCHECK(set_protocol);
-    // Create a chain of URLRequestJobFactories.  Keep |job_factory_| pointed
-    // at the beginning of the chain.
-    job_factory_ = CreateAndroidJobFactoryAndCookieMonster(
-        url_request_context_.get(), job_factory.Pass());
-    job_factory_.reset(new net::ProtocolInterceptJobFactory(
-        job_factory_.Pass(),
-        scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>(
-            new AwRequestInterceptor())));
-    job_factory_.reset(new net::ProtocolInterceptJobFactory(
-        job_factory_.Pass(),
-        developer_protocol_handler_.Pass()));
+
+    // Create a chain of URLRequestJobFactories.
+    ProtocolHandlerVector protocol_handlers;
+
+    protocol_handlers.push_back(
+        CreateAndroidContentProtocolHandler().release());
+    protocol_handlers.push_back(
+        CreateAndroidAssetFileProtocolHandler().release());
+    protocol_handlers.push_back(developer_protocol_handler_.release());
+    // The AwRequestInterceptor must come after the content and asset file job
+    // factories. This for WebViewClassic compatibility where it was not
+    // possible to intercept resource loads to resolvable content:// and
+    // file:// URIs.
+    // This is achieved by the Content and AssetFile jobs handling only
+    // resolvable URLRequests
+    protocol_handlers.push_back(new AwRequestInterceptor());
+    job_factory_ = WrapFactoryWithProtocolHandlers(
+        job_factory.PassAs<net::URLRequestJobFactory>(), protocol_handlers);
+
+    #if 0
+      // Alternative approach:

[boliu, 2013/03/01 18:44:11]

I like this alternative approach better, because it's more explicit than setting
up a chain of JobFactories.

[mnaganov (inactive), 2013/03/04 09:53:44]

But on the other hand, it's more consistent with the rest of Chromium code. See
the monstrous https://chromiumcodereview.appspot.com/11308362

Also, we don't need FallbackProtocolHandler in this case. Right, Marcin?

I'm just not sure, if we really need a function for initializing this. Perhaps,
having the loop inlined here will look simpler.

[boliu, 2013/03/04 19:55:46]

I don't feel very strongly about this. Seems too minor to worry about.

There is no example in chrome of chaining ProtocolInterceptJobFactory *at one
spot*. They do use this flexibility for initializing AppRequestContext, but
that's only one layer and it's conditional upon if it's an app context. We've
got 3 static ones, so maybe we have the freedom to do this differently.

Perhaps we should just load a bunch of urls and see which way is faster :p

+      job_factory_ = new net::ProtocolInterceptJobFactory(
+        job_factory.Pass(),
+        new FallbackProtocolHandler(
+            &protocol_handlers,
+            make_scoped_ptr(new AwRequestInterceptor()));
+    #endif
+
     url_request_context_->set_job_factory(job_factory_.get());
   }
+
   return url_request_context_.get();
 }
 
 scoped_refptr<base::SingleThreadTaskRunner>
 AwURLRequestContextGetter::GetNetworkTaskRunner() const {
   return BrowserThread::GetMessageLoopProxyForThread(BrowserThread::IO);
 }
 
 void AwURLRequestContextGetter::SetProtocolHandlers(
     scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
         blob_protocol_handler,
     scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
         file_system_protocol_handler,
     scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
         developer_protocol_handler,
     scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
         chrome_protocol_handler,
     scoped_ptr<net::URLRequestJobFactory::ProtocolHandler>
         chrome_devtools_protocol_handler) {
   blob_protocol_handler_ = blob_protocol_handler.Pass();
   file_system_protocol_handler_ = file_system_protocol_handler.Pass();
   developer_protocol_handler_ = developer_protocol_handler.Pass();
   chrome_protocol_handler_ = chrome_protocol_handler.Pass();
   chrome_devtools_protocol_handler_ = chrome_devtools_protocol_handler.Pass();
 }
 
 }  // namespace android_webview