Move shell interfaces into the shell.mojom namespace.

mojo/shell/application_package_apptest.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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 19 matching lines @@
 using GetNameCallback =
     test::mojom::ApplicationPackageApptestService::GetNameCallback;
 
 class ProvidedApplicationDelegate
     : public ApplicationDelegate,
       public InterfaceFactory<test::mojom::ApplicationPackageApptestService>,
       public test::mojom::ApplicationPackageApptestService,
       public base::SimpleThread {
  public:
   ProvidedApplicationDelegate(const std::string& name,
-                              InterfaceRequest<Application> request,
+                              InterfaceRequest<mojom::Application> request,
                               const Callback<void()>& destruct_callback)
       : base::SimpleThread(name),
         name_(name),
         request_(std::move(request)),
         destruct_callback_(destruct_callback) {
     Start();
   }
   ~ProvidedApplicationDelegate() override {
     Join();
     destruct_callback_.Run();
@@ skipping 21 matching lines @@
   }
 
   // base::SimpleThread:
   void Run() override {
     ApplicationRunner(this).Run(request_.PassMessagePipe().release().value(),
                                 false);
     delete this;
   }
 
   const std::string name_;
-  InterfaceRequest<Application> request_;
+  InterfaceRequest<mojom::Application> request_;
   const Callback<void()> destruct_callback_;
   WeakBindingSet<test::mojom::ApplicationPackageApptestService> bindings_;
 
   DISALLOW_COPY_AND_ASSIGN(ProvidedApplicationDelegate);
 };
 
 class ApplicationPackageApptestDelegate
     : public ApplicationDelegate,
-      public InterfaceFactory<ContentHandler>,
+      public InterfaceFactory<mojom::ContentHandler>,
       public InterfaceFactory<test::mojom::ApplicationPackageApptestService>,
-      public ContentHandler,
+      public mojom::ContentHandler,
       public test::mojom::ApplicationPackageApptestService {
  public:
   ApplicationPackageApptestDelegate() {}
   ~ApplicationPackageApptestDelegate() override {}
 
  private:
   // ApplicationDelegate:
   void Initialize(ApplicationImpl* app) override {}
   bool AcceptConnection(ApplicationConnection* connection) override {
     connection->AddService<ContentHandler>(this);
     connection->AddService<test::mojom::ApplicationPackageApptestService>(this);
     return true;
   }
 
-  // InterfaceFactory<ContentHandler>:
+  // InterfaceFactory<mojom::ContentHandler>:
   void Create(ApplicationConnection* connection,
-              InterfaceRequest<ContentHandler> request) override {
+              InterfaceRequest<mojom::ContentHandler> request) override {
     content_handler_bindings_.AddBinding(this, std::move(request));
   }
 
   // InterfaceFactory<test::mojom::ApplicationPackageApptestService>:
   void Create(ApplicationConnection* connection,
               InterfaceRequest<test::mojom::ApplicationPackageApptestService>
                   request) override {
     bindings_.AddBinding(this, std::move(request));
   }
 
-  // ContentHandler:
-  void StartApplication(InterfaceRequest<Application> request,
+  // mojom::ContentHandler:
+  void StartApplication(InterfaceRequest<mojom::Application> request,
                         URLResponsePtr response,
                         const Callback<void()>& destruct_callback) override {
     const std::string url = response->url;
     if (url == "mojo://package_test_a/") {
       new ProvidedApplicationDelegate("A", std::move(request),
                                       destruct_callback);
     } else if (url == "mojo://package_test_b/") {
       new ProvidedApplicationDelegate("B", std::move(request),
                                       destruct_callback);
     }
   }
 
   // test::mojom::ApplicationPackageApptestService:
   void GetName(const GetNameCallback& callback) override {
     callback.Run("ROOT");
   }
 
   std::vector<scoped_ptr<ApplicationDelegate>> delegates_;
-  WeakBindingSet<ContentHandler> content_handler_bindings_;
+  WeakBindingSet<mojom::ContentHandler> content_handler_bindings_;
   WeakBindingSet<test::mojom::ApplicationPackageApptestService> bindings_;
 
   DISALLOW_COPY_AND_ASSIGN(ApplicationPackageApptestDelegate);
 };
 
 void ReceiveName(std::string* out_name,
                  base::RunLoop* loop,
                  const String& name) {
   *out_name = name;
   loop->Quit();
@@ skipping 49 matching lines @@
     base::RunLoop run_loop;
     std::string b_name;
     service_b->GetName(base::Bind(&ReceiveName, &b_name, &run_loop));
     run_loop.Run();
     EXPECT_EQ("B", b_name);
   }
 }
 
 }  // namespace shell
 }  // namespace mojo