Move shell interfaces into the shell.mojom namespace.

mojo/shell/runner/child/runner_connection.cc

 // Copyright 2015 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/runner/child/runner_connection.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 54 matching lines @@
   Unblocker GetUnblocker() { return Unblocker(this); }
 
  private:
   base::WaitableEvent event_;
   base::Closure run_after_;
 
   DISALLOW_COPY_AND_ASSIGN(Blocker);
 };
 
 using GotApplicationRequestCallback =
-    base::Callback<void(InterfaceRequest<Application>)>;
+    base::Callback<void(InterfaceRequest<mojom::Application>)>;
 
 void OnCreateMessagePipe(ScopedMessagePipeHandle* result,
                          Blocker::Unblocker unblocker,
                          ScopedMessagePipeHandle pipe) {
   *result = std::move(pipe);
   unblocker.Unblock(base::Bind(&base::DoNothing));
 }
 
-void OnGotApplicationRequest(InterfaceRequest<Application>* out_request,
-                             InterfaceRequest<Application> request) {
+void OnGotApplicationRequest(InterfaceRequest<mojom::Application>* out_request,
+                             InterfaceRequest<mojom::Application> request) {
   *out_request = std::move(request);
 }
 
 class ChildControllerImpl;
 
 class RunnerConnectionImpl : public RunnerConnection {
  public:
   RunnerConnectionImpl() : controller_thread_("controller_thread") {
     StartControllerThread();
   }
   ~RunnerConnectionImpl() override {
     controller_runner_->PostTask(
         FROM_HERE, base::Bind(&RunnerConnectionImpl::ShutdownOnControllerThread,
                               base::Unretained(this)));
     controller_thread_.Stop();
   }
 
   // Returns true if a connection to the runner has been established and
   // |request| has been modified, false if no connection was established.
-  bool WaitForApplicationRequest(InterfaceRequest<Application>* request,
+  bool WaitForApplicationRequest(InterfaceRequest<mojom::Application>* request,
                                  ScopedMessagePipeHandle handle);
 
   ChildControllerImpl* controller() const { return controller_.get(); }
 
   void set_controller(scoped_ptr<ChildControllerImpl> controller) {
     controller_ = std::move(controller);
   }
 
  private:
   void StartControllerThread() {
@@ skipping 11 matching lines @@
 
   base::Thread controller_thread_;
   scoped_refptr<base::SingleThreadTaskRunner> controller_runner_;
 
   // Accessed only on the controller thread.
   scoped_ptr<ChildControllerImpl> controller_;
 
   DISALLOW_COPY_AND_ASSIGN(RunnerConnectionImpl);
 };
 
-class ChildControllerImpl : public ChildController {
+class ChildControllerImpl : public mojom::ChildController {
  public:
   ~ChildControllerImpl() override {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     // TODO(vtl): Pass in the result from |MainMain()|.
     on_app_complete_.Run(MOJO_RESULT_UNIMPLEMENTED);
   }
 
   // To be executed on the controller thread. Creates the |ChildController|,
   // etc.
@@ skipping 17 matching lines @@
     binding_.set_connection_error_handler([this]() { OnConnectionError(); });
   }
 
   void OnConnectionError() {
     // A connection error means the connection to the shell is lost. This is not
     // recoverable.
     DLOG(ERROR) << "Connection error to the shell.";
     _exit(1);
   }
 
-  // |ChildController| methods:
-  void StartApp(InterfaceRequest<Application> application_request,
+  // |mojom::ChildController| methods:
+  void StartApp(InterfaceRequest<mojom::Application> application_request,
                 const StartAppCallback& on_app_complete) override {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     on_app_complete_ = on_app_complete;
     unblocker_.Unblock(
         base::Bind(&ChildControllerImpl::ReturnApplicationRequestOnMainThread,
                    callback_, base::Passed(&application_request)));
   }
 
   void ExitNow(int32_t exit_code) override {
     DVLOG(2) << "ChildControllerImpl::ExitNow(" << exit_code << ")";
     _exit(exit_code);
   }
 
  private:
   ChildControllerImpl(RunnerConnectionImpl* connection,
                       const GotApplicationRequestCallback& callback,
                       const Blocker::Unblocker& unblocker)
       : connection_(connection),
         callback_(callback),
         unblocker_(unblocker),
         binding_(this) {}
 
   static void ReturnApplicationRequestOnMainThread(
       const GotApplicationRequestCallback& callback,
-      InterfaceRequest<Application> application_request) {
+      InterfaceRequest<mojom::Application> application_request) {
     callback.Run(std::move(application_request));
   }
 
   base::ThreadChecker thread_checker_;
   RunnerConnectionImpl* const connection_;
   GotApplicationRequestCallback callback_;
   Blocker::Unblocker unblocker_;
   StartAppCallback on_app_complete_;
 
   Binding<ChildController> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildControllerImpl);
 };
 
 bool RunnerConnectionImpl::WaitForApplicationRequest(
-    InterfaceRequest<Application>* request,
+    InterfaceRequest<mojom::Application>* request,
     ScopedMessagePipeHandle handle) {
   // If a valid message pipe to the runner was not provided, look for one on the
   // command line.
   if (!handle.is_valid()) {
     edk::ScopedPlatformHandle platform_channel =
         edk::PlatformChannelPair::PassClientHandleFromParentProcess(
             *base::CommandLine::ForCurrentProcess());
     if (!platform_channel.is_valid())
       return false;
     edk::SetParentPipeHandle(std::move(platform_channel));
@@ skipping 19 matching lines @@
 
   return true;
 }
 
 }  // namespace
 
 RunnerConnection::~RunnerConnection() {}
 
 // static
 RunnerConnection* RunnerConnection::ConnectToRunner(
-    InterfaceRequest<Application>* request,
+    InterfaceRequest<mojom::Application>* request,
     ScopedMessagePipeHandle handle) {
   RunnerConnectionImpl* connection = new RunnerConnectionImpl;
   if (!connection->WaitForApplicationRequest(request, std::move(handle))) {
     delete connection;
     return nullptr;
   }
   return connection;
 }
 
 RunnerConnection::RunnerConnection() {}
 
 }  // namespace shell
 }  // namespace mojo