Adds ability for chrome to behave as mojo_runner

mojo/shell/background/background_shell.cc

 // Copyright 2016 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 "mojo/shell/background/background_shell.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 54 matching lines @@
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MojoMessageLoop);
 };
 
 }  // namespace
 
 // Manages the thread to startup mojo.
 class BackgroundShell::MojoThread : public base::SimpleThread {
  public:
-  explicit MojoThread(
-      const std::vector<CommandLineSwitch>& command_line_switches)
+  explicit MojoThread(NativeRunnerDelegate* native_runner_delegate)
       : SimpleThread("mojo-background-shell"),
-        command_line_switches_(command_line_switches) {}
+        native_runner_delegate_(native_runner_delegate) {}
   ~MojoThread() override {}
 
   void CreateShellClientRequest(base::WaitableEvent* signal,
                                 scoped_ptr<ConnectParams> params,
                                 mojom::ShellClientRequest* request) {
     // Only valid to call this on the background thread.
     DCHECK_EQ(message_loop_, base::MessageLoop::current());
 
     // Ownership of |loader| passes to ApplicationManager.
     const GURL url = params->target().url();
@@ skipping 30 matching lines @@
 
     Context::EnsureEmbedderIsInitialized();
 
     message_loop_->BindToCurrentThread();
 
     base::FilePath shell_dir;
     PathService::Get(base::DIR_MODULE, &shell_dir);
 
     scoped_ptr<Context> context(new Context);
     context_ = context.get();
-    context_->set_command_line_switches(command_line_switches_);
+    context_->set_native_runner_delegate(native_runner_delegate_);
     context_->Init(shell_dir);
 
     message_loop_->Run();
 
     // Has to happen after run, but while messageloop still valid.
     context_->Shutdown();
 
     // Context has to be destroyed after the MessageLoop has been destroyed.
     message_loop.reset();
     context_ = nullptr;
   }
 
  private:
   void OnGotApplicationRequest(const GURL& url,
                                base::WaitableEvent* signal,
                                mojom::ShellClientRequest* request_result,
                                mojom::ShellClientRequest actual_request) {
     *request_result = std::move(actual_request);
     // Trigger destruction of the loader.
     context_->application_manager()->SetLoaderForURL(nullptr, url);
     signal->Signal();
   }
 
   // We own this. It's created on the main thread, but destroyed on the
   // background thread.
   MojoMessageLoop* message_loop_ = nullptr;
   // Created in Run() on the background thread.
   Context* context_ = nullptr;
 
-  const std::vector<CommandLineSwitch> command_line_switches_;
+  NativeRunnerDelegate* native_runner_delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(MojoThread);
 };
 
 BackgroundShell::BackgroundShell() {}
 
 BackgroundShell::~BackgroundShell() {
   thread_->Stop();
 }
 
-void BackgroundShell::Init(
-    const std::vector<CommandLineSwitch>& command_line_switches) {
+void BackgroundShell::Init(NativeRunnerDelegate* native_runner_delegate) {
   DCHECK(!thread_);
-  thread_.reset(new MojoThread(command_line_switches));
+  thread_.reset(new MojoThread(native_runner_delegate));
   thread_->Start();
 }
 
 mojom::ShellClientRequest BackgroundShell::CreateShellClientRequest(
     const GURL& url) {
   scoped_ptr<ConnectParams> params(new ConnectParams);
   params->set_target(
       Identity(url, std::string(), GetPermissiveCapabilityFilter()));
   mojom::ShellClientRequest request;
   base::WaitableEvent signal(true, false);
   thread_->message_loop()->task_runner()->PostTask(
       FROM_HERE, base::Bind(&MojoThread::CreateShellClientRequest,
                             base::Unretained(thread_.get()), &signal,
                             base::Passed(&params), &request));
   signal.Wait();
   return request;
 }
 
 }  // namespace shell
 }  // namespace mojo