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

mojo/shell/public/cpp/lib/connection_impl.cc

 // Copyright 2014 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/public/cpp/lib/connection_impl.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "mojo/shell/public/cpp/connection.h"
 #include "mojo/shell/public/cpp/interface_binder.h"
 
 namespace mojo {
 namespace internal {
 
 ////////////////////////////////////////////////////////////////////////////////
 // ConnectionImpl, public:
 
 ConnectionImpl::ConnectionImpl(
     const std::string& connection_url,
     const std::string& remote_url,
     uint32_t remote_id,
-    InterfaceProviderPtr remote_interfaces,
-    InterfaceRequest<InterfaceProvider> local_interfaces,
+    shell::mojom::InterfaceProviderPtr remote_interfaces,
+    shell::mojom::InterfaceProviderRequest local_interfaces,
     const std::set<std::string>& allowed_interfaces)
     : connection_url_(connection_url),
       remote_url_(remote_url),
       remote_id_(remote_id),
       content_handler_id_(0u),
       remote_ids_valid_(false),
       local_binding_(this),
       remote_interfaces_(std::move(remote_interfaces)),
       allowed_interfaces_(allowed_interfaces),
       allow_all_interfaces_(allowed_interfaces_.size() == 1 &&
@@ skipping 49 matching lines @@
 }
 
 const std::string& ConnectionImpl::GetConnectionURL() {
   return connection_url_;
 }
 
 const std::string& ConnectionImpl::GetRemoteApplicationURL() {
   return remote_url_;
 }
 
-InterfaceProvider* ConnectionImpl::GetRemoteInterfaces() {
+shell::mojom::InterfaceProvider* ConnectionImpl::GetRemoteInterfaces() {
   return remote_interfaces_.get();
 }
 
-InterfaceProvider* ConnectionImpl::GetLocalInterfaces() {
+shell::mojom::InterfaceProvider* ConnectionImpl::GetLocalInterfaces() {
   return this;
 }
 
 void ConnectionImpl::SetRemoteInterfaceProviderConnectionErrorHandler(
     const Closure& handler) {
   remote_interfaces_.set_connection_error_handler(handler);
 }
 
 bool ConnectionImpl::GetRemoteApplicationID(uint32_t* remote_id) const {
   if (!remote_ids_valid_)
@@ skipping 18 matching lines @@
     return;
   }
   remote_id_callbacks_.push_back(callback);
 }
 
 base::WeakPtr<Connection> ConnectionImpl::GetWeakPtr() {
   return weak_factory_.GetWeakPtr();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
-// ConnectionImpl, InterfaceProvider implementation:
+// ConnectionImpl, shell::mojom::InterfaceProvider implementation:
 
 void ConnectionImpl::GetInterface(const mojo::String& interface_name,
                                   ScopedMessagePipeHandle handle) {
   auto iter = name_to_binder_.find(interface_name);
   InterfaceBinder* binder = iter != name_to_binder_.end() ? iter->second :
       default_binder_;
   if (binder)
     binder->BindInterface(this, interface_name, std::move(handle));
 }
 
@@ skipping 17 matching lines @@
   remote_id_ = target_application_id;
   content_handler_id_ = content_handler_id;
   std::vector<Closure> callbacks;
   callbacks.swap(remote_id_callbacks_);
   for (auto callback : callbacks)
     callback.Run();
 }
 
 }  // namespace internal
 }  // namespace mojo