Move shell interfaces into the shell.mojom namespace.

mandoline/services/core_services/core_services_application_delegate.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 "mandoline/services/core_services/core_services_application_delegate.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
@@ skipping 15 matching lines @@
 
 namespace core_services {
 
 // A helper class for hosting a mojo::ApplicationImpl on its own thread.
 class ApplicationThread : public base::SimpleThread {
  public:
   ApplicationThread(const base::WeakPtr<CoreServicesApplicationDelegate>
                         core_services_application,
                     const std::string& url,
                     scoped_ptr<mojo::ApplicationDelegate> delegate,
-                    mojo::InterfaceRequest<mojo::Application> request,
+                    mojo::ApplicationRequest request,
                     const mojo::Callback<void()>& destruct_callback)
       : base::SimpleThread(url),
         core_services_application_(core_services_application),
         core_services_application_task_runner_(base::MessageLoop::current()
                                                    ->task_runner()),
         url_(url),
         delegate_(std::move(delegate)),
         request_(std::move(request)),
         destruct_callback_(destruct_callback) {}
 
@@ skipping 19 matching lines @@
                    core_services_application_,
                    this));
   }
 
  private:
   base::WeakPtr<CoreServicesApplicationDelegate> core_services_application_;
   scoped_refptr<base::SingleThreadTaskRunner>
       core_services_application_task_runner_;
   std::string url_;
   scoped_ptr<mojo::ApplicationDelegate> delegate_;
-  mojo::InterfaceRequest<mojo::Application> request_;
+  mojo::ApplicationRequest request_;
   mojo::Callback<void()> destruct_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ApplicationThread);
 };
 
 CoreServicesApplicationDelegate::CoreServicesApplicationDelegate()
     : weak_factory_(this) {
 }
 
 CoreServicesApplicationDelegate::~CoreServicesApplicationDelegate() {
@@ skipping 23 matching lines @@
 
 void CoreServicesApplicationDelegate::Quit() {
   // This will delete all threads. This also performs a blocking join, waiting
   // for the threads to end.
   application_threads_.clear();
   weak_factory_.InvalidateWeakPtrs();
 }
 
 void CoreServicesApplicationDelegate::Create(
     mojo::ApplicationConnection* connection,
-    mojo::InterfaceRequest<mojo::ContentHandler> request) {
+    mojo::InterfaceRequest<mojo::shell::mojom::ContentHandler> request) {
   handler_bindings_.AddBinding(this, std::move(request));
 }
 
 void CoreServicesApplicationDelegate::StartApplication(
-    mojo::InterfaceRequest<mojo::Application> request,
+    mojo::ApplicationRequest request,
     mojo::URLResponsePtr response,
     const mojo::Callback<void()>& destruct_callback) {
   const std::string url = response->url;
 
   scoped_ptr<mojo::ApplicationDelegate> delegate;
   if (url == "mojo://clipboard/") {
     delegate.reset(new clipboard::ClipboardApplicationDelegate);
   } else if (url == "mojo://filesystem/") {
     delegate.reset(new filesystem::FileSystemApp);
   } else if (url == "mojo://tracing/") {
@@ skipping 13 matching lines @@
   }
 
   scoped_ptr<ApplicationThread> thread(new ApplicationThread(
       weak_factory_.GetWeakPtr(), url, std::move(delegate), std::move(request),
       destruct_callback));
   thread->Start();
   application_threads_.push_back(std::move(thread));
 }
 
 }  // namespace core_services