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

mojo/shell/capability_filter_test.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/capability_filter_test.h"
 
 #include <utility>
 
 #include "base/macros.h"
 #include "base/stl_util.h"
@@ skipping 273 matching lines @@
   application_manager_.reset(
       new ApplicationManager(make_scoped_ptr(CreatePackageManager())));
   CreateLoader<ServiceApplication>("test:service");
   CreateLoader<ServiceApplication>("test:service2");
 }
 
 void CapabilityFilterTest::TearDown() {
   application_manager_.reset();
 }
 
-class InterfaceProviderImpl : public InterfaceProvider {
+class InterfaceProviderImpl : public shell::mojom::InterfaceProvider {
  public:
   explicit InterfaceProviderImpl(
-      InterfaceRequest<InterfaceProvider> interfaces,
+      shell::mojom::InterfaceProviderRequest interfaces,
       InterfaceFactory<Validator>* factory)
       : binding_(this, std::move(interfaces)),
         factory_(factory) {}
   ~InterfaceProviderImpl() override {}
 
  private:
-  // InterfaceProvider method.
+  // shell::mojom::InterfaceProvider method.
   void GetInterface(const mojo::String& interface_name,
                     ScopedMessagePipeHandle client_handle) override {
     if (interface_name == Validator::Name_) {
       factory_->Create(nullptr,
                        MakeRequest<Validator>(std::move(client_handle)));
     }
   }
 
   Binding<InterfaceProvider> binding_;
   InterfaceFactory<Validator>* factory_;
 
   DISALLOW_COPY_AND_ASSIGN(InterfaceProviderImpl);
 };
 
 void CapabilityFilterTest::RunApplication(const std::string& url,
                                           const CapabilityFilter& filter) {
-  InterfaceProviderPtr remote_interfaces;
+  shell::mojom::InterfaceProviderPtr remote_interfaces;
 
   // We expose Validator to the test application via ConnectToApplication
   // because we don't allow the test application to connect to test:validator.
   // Adding it to the CapabilityFilter would interfere with the test.
-  InterfaceProviderPtr local_interfaces;
+  shell::mojom::InterfaceProviderPtr local_interfaces;
   new InterfaceProviderImpl(GetProxy(&local_interfaces), validator_);
   scoped_ptr<ConnectToApplicationParams> params(
       new ConnectToApplicationParams);
   params->SetTarget(Identity(GURL(url), std::string(), filter));
   params->set_remote_interfaces(GetProxy(&remote_interfaces));
   params->set_local_interfaces(std::move(local_interfaces));
   params->set_on_application_end(base::MessageLoop::QuitWhenIdleClosure());
   application_manager_->ConnectToApplication(std::move(params));
 }
 
 void CapabilityFilterTest::InitValidator(
     const std::set<std::string>& expectations) {
   validator_ = new ConnectionValidator(expectations, &loop_);
   application_manager()->SetLoaderForURL(make_scoped_ptr(validator_),
                                           GURL("test:validator"));
 }
 
 void CapabilityFilterTest::RunTest() {
   loop()->Run();
   EXPECT_TRUE(validator_->expectations_met());
   if (!validator_->expectations_met())
     validator_->PrintUnmetExpectations();
 }
 
 }  // namespace test
 }  // namespace shell
 }  // namespace mojo