Add --force-in-process flag to shell.

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 <stdio.h>
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/interfaces/application/shell.mojom.h"
 #include "mojo/services/content_handler/public/interfaces/content_handler.mojom.h"
 #include "shell/application_manager/fetcher.h"
 #include "shell/application_manager/local_fetcher.h"
 #include "shell/application_manager/network_fetcher.h"
 
 namespace mojo {
 
 namespace {
+
 // Used by TestAPI.
 bool has_created_instance = false;
 
 GURL StripQueryFromURL(const GURL& url) {
   GURL::Replacements repl;
   repl.SetQueryStr("");
   std::string result = url.ReplaceComponents(repl).spec();
 
   // Remove the dangling '?' because it's ugly.
   base::ReplaceChars(result, "?", "", &result);
@@ skipping 253 matching lines @@
   if (iter != mime_type_to_url_.end()) {
     LoadWithContentHandler(iter->second, request.Pass(),
                            fetcher->AsURLResponse(blocking_pool_, 0));
     return;
   }
 
   // TODO(aa): Sanity check that the thing we got looks vaguely like a mojo
   // application. That could either mean looking for the platform-specific dll
   // header, or looking for some specific mojo signature prepended to the
   // library.
+  // TODO(vtl): (Maybe this should be done by the factory/runner?)
+
+  NativeRunnerFactory::Options options;
+  if (url_to_native_options_.find(fetcher->GetURL()) !=

[qsr, 2015/03/05 14:47:52]

As you put it in the comment in SetNativeOptionsForURL, you need to remove the
query string here (at the other place, I would just DCHECK that there is no
query string).

[viettrungluu, 2015/03/05 18:30:10]

That's easier now that you've landed your change. ;)

I'll send you a change for this....

+      url_to_native_options_.end()) {
+    DVLOG(2) << "Applying stored native options to resolved URL "
+             << fetcher->GetURL() << " (requested URL " << requested_url << ")";
+    options = url_to_native_options_[fetcher->GetURL()];
+  }
 
   fetcher->AsPath(
       blocking_pool_,
       base::Bind(&ApplicationManager::RunNativeApplication,
                  weak_ptr_factory_.GetWeakPtr(), base::Passed(request.Pass()),
-                 cleanup_behavior, base::Passed(fetcher.Pass())));
+                 options, cleanup_behavior, base::Passed(fetcher.Pass())));
 }
 
 void ApplicationManager::RunNativeApplication(
     InterfaceRequest<Application> application_request,
+    const NativeRunnerFactory::Options& options,
     NativeRunner::CleanupBehavior cleanup_behavior,
     scoped_ptr<Fetcher> fetcher,
     const base::FilePath& path,
     bool path_exists) {
   // We only passed fetcher to keep it alive. Done with it now.
   fetcher.reset();
 
   DCHECK(application_request.is_pending());
 
   if (!path_exists) {
     LOG(ERROR) << "Library not started because library path '" << path.value()
                << "' does not exist.";
     return;
   }
 
-  NativeRunner* runner = native_runner_factory_->Create().release();
+  NativeRunner* runner = native_runner_factory_->Create(options).release();
   native_runners_.push_back(runner);
   runner->Start(path, cleanup_behavior, application_request.Pass(),
                 base::Bind(&ApplicationManager::CleanupRunner,
                            weak_ptr_factory_.GetWeakPtr(), runner));
 }
 
 void ApplicationManager::RegisterExternalApplication(
     const GURL& url,
     const std::vector<std::string>& args,
     ApplicationPtr application) {
@@ skipping 48 matching lines @@
   if (it != scheme_to_loader_.end())
     delete it->second;
   scheme_to_loader_[scheme] = loader.release();
 }
 
 void ApplicationManager::SetArgsForURL(const std::vector<std::string>& args,
                                        const GURL& url) {
   url_to_args_[url] = args;
 }
 
+void ApplicationManager::SetNativeOptionsForURL(
+    const NativeRunnerFactory::Options& options,
+    const GURL& url) {
+  // Apply mappings and resolution to get the resolved URL.
+  GURL resolved_url = delegate_->ResolveURL(delegate_->ResolveMappings(url));
+  // TODO(vtl): We should probably also remove/disregard the query string (and
+  // maybe canonicalize in other ways).
+  DVLOG(2) << "Storing native options for resolved URL " << resolved_url
+           << " (original URL " << url << ")";
+  url_to_native_options_[resolved_url] = options;
+}
+
 ApplicationLoader* ApplicationManager::GetLoaderForURL(const GURL& url) {
   auto url_it = url_to_loader_.find(StripQueryFromURL(url));
   if (url_it != url_to_loader_.end())
     return url_it->second;
   auto scheme_it = scheme_to_loader_.find(url.scheme());
   if (scheme_it != scheme_to_loader_.end())
     return scheme_it->second;
   return NULL;
 }
 
@@ skipping 35 matching lines @@
     return Array<String>::From(args_it->second);
   return Array<String>();
 }
 
 void ApplicationManager::CleanupRunner(NativeRunner* runner) {
   native_runners_.erase(
       std::find(native_runners_.begin(), native_runners_.end(), runner));
 }
 
 }  // namespace mojo