Move InterfaceProvider into the shell::mojom namespace like the rest of the shell interfaces.

mojo/shell/standalone/context.cc

 // Copyright 2013 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/standalone/context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 94 matching lines @@
       LOG(ERROR) << "Invalid value for switch " << switches::kContentHandlers
                  << ": '" << parts[i + 1] << "' is not a valid URL.";
       return;
     }
     // TODO(eseidel): We should also validate that the mimetype is valid
     // net/base/mime_util.h could do this, but we don't want to depend on net.
     manager->RegisterContentHandler(parts[i], url);
   }
 }
 
-class TracingInterfaceProvider : public InterfaceProvider {
+class TracingInterfaceProvider : public shell::mojom::InterfaceProvider {
  public:
   TracingInterfaceProvider(Tracer* tracer,
-                           InterfaceRequest<InterfaceProvider> request)
+                           shell::mojom::InterfaceProviderRequest request)
       : tracer_(tracer), binding_(this, std::move(request)) {}
   ~TracingInterfaceProvider() override {}
 
+  // shell::mojom::InterfaceProvider:
   void GetInterface(const mojo::String& interface_name,
                     ScopedMessagePipeHandle client_handle) override {
     if (tracer_ && interface_name == tracing::TraceProvider::Name_) {
       tracer_->ConnectToProvider(
           MakeRequest<tracing::TraceProvider>(std::move(client_handle)));
     }
   }
 
  private:
   Tracer* tracer_;
-  StrongBinding<InterfaceProvider> binding_;
+  StrongBinding<shell::mojom::InterfaceProvider> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(TracingInterfaceProvider);
 };
 
 }  // namespace
 
 Context::Context()
     : package_manager_(nullptr), main_entry_time_(base::Time::Now()) {}
 
 Context::~Context() {
@@ skipping 42 matching lines @@
     runner_factory.reset(
         new InProcessNativeRunnerFactory(task_runners_->blocking_pool()));
   } else {
     runner_factory.reset(
         new OutOfProcessNativeRunnerFactory(task_runners_->blocking_pool()));
   }
   application_manager_.reset(new ApplicationManager(
       make_scoped_ptr(package_manager_), std::move(runner_factory),
       task_runners_->blocking_pool()));
 
-  InterfaceProviderPtr tracing_remote_interfaces;
-  InterfaceProviderPtr tracing_local_interfaces;
+  shell::mojom::InterfaceProviderPtr tracing_remote_interfaces;
+  shell::mojom::InterfaceProviderPtr tracing_local_interfaces;
   new TracingInterfaceProvider(&tracer_, GetProxy(&tracing_local_interfaces));
 
   scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
   params->set_source(Identity(GURL("mojo:shell"), std::string(),
                               GetPermissiveCapabilityFilter()));
   params->SetTarget(Identity(GURL("mojo:tracing"), std::string(),
                              GetPermissiveCapabilityFilter()));
   params->set_remote_interfaces(GetProxy(&tracing_remote_interfaces));
   params->set_local_interfaces(std::move(tracing_local_interfaces));
   application_manager_->ConnectToApplication(std::move(params));
@@ skipping 39 matching lines @@
 }
 
 void Context::OnShutdownComplete() {
   DCHECK_EQ(base::MessageLoop::current()->task_runner(),
             task_runners_->shell_runner());
   base::MessageLoop::current()->QuitWhenIdle();
 }
 
 void Context::Run(const GURL& url) {
   DCHECK(app_complete_callback_.is_null());
-  InterfaceProviderPtr remote_interfaces;
-  InterfaceProviderPtr local_interfaces;
+  shell::mojom::InterfaceProviderPtr remote_interfaces;
+  shell::mojom::InterfaceProviderPtr local_interfaces;
 
   app_urls_.insert(url);
 
   scoped_ptr<ConnectToApplicationParams> params(new ConnectToApplicationParams);
   params->SetTarget(
       Identity(url, std::string(), GetPermissiveCapabilityFilter()));
   params->set_remote_interfaces(GetProxy(&remote_interfaces));
   params->set_local_interfaces(std::move(local_interfaces));
   params->set_on_application_end(
       base::Bind(&Context::OnApplicationEnd, base::Unretained(this), url));
@@ skipping 25 matching lines @@
         base::MessageLoop::current()->QuitWhenIdle();
       } else {
         app_complete_callback_.Run();
       }
     }
   }
 }
 
 }  // namespace shell
 }  // namespace mojo