Add some |using mojo::...;|s to //shell .cc files.

shell/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 "shell/context.h"
 
 #include <vector>
 
 #include "base/base_switches.h"
 #include "base/bind.h"
@@ skipping 20 matching lines @@
 #include "services/tracing/tracing.mojom.h"
 #include "shell/application_manager/application_loader.h"
 #include "shell/application_manager/application_manager.h"
 #include "shell/command_line_util.h"
 #include "shell/filename_util.h"
 #include "shell/in_process_native_runner.h"
 #include "shell/out_of_process_native_runner.h"
 #include "shell/switches.h"
 #include "url/gurl.h"
 
+using mojo::ServiceProvider;
+using mojo::ServiceProviderPtr;
+
 namespace shell {
 namespace {
 
 // Used to ensure we only init once.
 class Setup {
  public:
   Setup() {
     mojo::embedder::Init(
         make_scoped_ptr(new mojo::embedder::SimplePlatformSupport()));
   }
@@ skipping 113 matching lines @@
                  << ": '" << force_in_process_url << "'is not a valid URL.";
       return;
     }
 
     NativeRunnerFactory::Options options;
     options.force_in_process = true;
     manager->SetNativeOptionsForURL(options, gurl);
   }
 }
 
-class TracingServiceProvider : public mojo::ServiceProvider {
+class TracingServiceProvider : public ServiceProvider {
  public:
   explicit TracingServiceProvider(
-      mojo::InterfaceRequest<mojo::ServiceProvider> request)
+      mojo::InterfaceRequest<ServiceProvider> request)
       : binding_(this, request.Pass()) {}
   ~TracingServiceProvider() override {}
 
   void ConnectToService(const mojo::String& service_name,
                         mojo::ScopedMessagePipeHandle client_handle) override {
     if (service_name == tracing::TraceController::Name_) {
       new mojo::TraceControllerImpl(
           mojo::MakeRequest<tracing::TraceController>(client_handle.Pass()));
     }
   }
@@ skipping 90 matching lines @@
     runner_factory.reset(new InProcessNativeRunnerFactory(this));
   application_manager_.set_blocking_pool(task_runners_->blocking_pool());
   application_manager_.set_native_runner_factory(runner_factory.Pass());
   application_manager_.set_disable_cache(
       base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kDisableCache));
 
   InitContentHandlers(&application_manager_, command_line);
   InitNativeOptions(&application_manager_, command_line);
 
-  mojo::ServiceProviderPtr tracing_service_provider_ptr;
+  ServiceProviderPtr tracing_service_provider_ptr;
   new TracingServiceProvider(mojo::GetProxy(&tracing_service_provider_ptr));
   application_manager_.ConnectToApplication(
       GURL("mojo:tracing"), GURL(""), nullptr,
       tracing_service_provider_ptr.Pass(), base::Closure());
 
   return true;
 }
 
 void Context::Shutdown() {
   TRACE_EVENT0("mojo_shell", "Context::Shutdown");
@@ skipping 12 matching lines @@
   return url_resolver_.ApplyMappings(url);
 }
 
 void Context::OnShutdownComplete() {
   DCHECK_EQ(base::MessageLoop::current()->task_runner(),
             task_runners_->shell_runner());
   base::MessageLoop::current()->Quit();
 }
 
 void Context::Run(const GURL& url) {
-  mojo::ServiceProviderPtr services;
-  mojo::ServiceProviderPtr exposed_services;
+  ServiceProviderPtr services;
+  ServiceProviderPtr exposed_services;
 
   app_urls_.insert(url);
   application_manager_.ConnectToApplication(
       url, GURL(), mojo::GetProxy(&services), exposed_services.Pass(),
       base::Bind(&Context::OnApplicationEnd, base::Unretained(this), url));
 }
 
 void Context::OnApplicationEnd(const GURL& url) {
   if (app_urls_.find(url) != app_urls_.end()) {
     app_urls_.erase(url);
     if (app_urls_.empty() && base::MessageLoop::current()->is_running()) {
       DCHECK_EQ(base::MessageLoop::current()->task_runner(),
                 task_runners_->shell_runner());
       base::MessageLoop::current()->Quit();
     }
   }
 }
 
 }  // namespace shell