Offline By Default

shell/application_manager/application_manager.cc

 // Copyright 2014 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 "shell/application_manager/application_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 167 matching lines @@
 
   if (resolved_url.SchemeIsFile()) {
     new LocalFetcher(resolved_url, GetBaseURLAndQuery(resolved_url, nullptr),
                      callback);
     return;
   }
 
   if (!url_response_disk_cache_) {
     ConnectToService(GURL("mojo:url_response_disk_cache"),
                      &url_response_disk_cache_);
+    ConnectToService(GURL("mojo:network_service"), &network_service_);
+    ConnectToService(GURL("mojo:network_service"),
+                     &authenticating_network_service_);

[ppi, 2015/09/08 15:46:26]

Why this change is needed?

[qsr, 2015/09/11 15:47:58]

Because otherwise the network service is changed in the middle of the
initialization sequence, and it blocks because it expects an interceptor that
cannot be initialized correctly.

   }
 
-  if (!network_service_) {
-    ConnectToService(GURL("mojo:network_service"), &network_service_);
-  }
+  mojo::NetworkService* network_service = authenticating_network_service_.get();
 
   // NOTE: Attempting to initialize the apps used authentication for while
   // connecting to those apps would result in a recursive loop, so it has to be
   // explicitly avoided here. What this means in practice is that these apps
   // cannot themselves require authentication to obtain.
-  if (!initialized_authentication_interceptor_ &&
-      !EndsWith(resolved_url.path(), "/authentication.mojo", true) &&
-      !EndsWith(resolved_url.path(),
-                "/authenticating_url_loader_interceptor.mojo", true)) {
+  if (EndsWith(resolved_url.path(), "/authentication.mojo", true) ||
+      EndsWith(resolved_url.path(),
+               "/authenticating_url_loader_interceptor.mojo", true)) {
+    network_service = network_service_.get();
+  } else if (!initialized_authentication_interceptor_) {
     authentication::AuthenticationServicePtr authentication_service;
     ConnectToService(GURL("mojo:authentication"), &authentication_service);
     mojo::AuthenticatingURLLoaderInterceptorMetaFactoryPtr
         interceptor_meta_factory;
     ConnectToService(GURL("mojo:authenticating_url_loader_interceptor"),
                      &interceptor_meta_factory);
     mojo::URLLoaderInterceptorFactoryPtr interceptor_factory;
     interceptor_meta_factory->CreateURLLoaderInterceptorFactory(
         GetProxy(&interceptor_factory), authentication_service.Pass());
-    network_service_->RegisterURLLoaderInterceptor(interceptor_factory.Pass());
+    authenticating_network_service_->RegisterURLLoaderInterceptor(
+        interceptor_factory.Pass());
     initialized_authentication_interceptor_ = true;
   }
 
   new NetworkFetcher(options_.disable_cache, resolved_url,
-                     url_response_disk_cache_.get(), network_service_.get(),
-                     callback);
+                     url_response_disk_cache_.get(), network_service, callback);
 }
 
 bool ApplicationManager::ConnectToRunningApplication(
     const GURL& resolved_url,
     const GURL& requestor_url,
     InterfaceRequest<ServiceProvider>* services,
     ServiceProviderPtr* exposed_services) {
   GURL application_url = GetBaseURLAndQuery(resolved_url, nullptr);
   ShellImpl* shell_impl = GetShellImpl(application_url);
   if (!shell_impl)
@@ skipping 280 matching lines @@
     return args_it->second;
   return std::vector<std::string>();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace shell