Remove mojo:: part of mojo::shell:: nested namespace in //shell.

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"
 
-namespace mojo {
 namespace shell {
 namespace {
 
 // Used to ensure we only init once.
 class Setup {
  public:
   Setup() {
-    embedder::Init(make_scoped_ptr(new embedder::SimplePlatformSupport()));
+    mojo::embedder::Init(
+        make_scoped_ptr(new mojo::embedder::SimplePlatformSupport()));
   }
 
   ~Setup() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Setup);
 };
 
 bool ConfigureURLMappings(const base::CommandLine& command_line,
                           Context* context) {
@@ skipping 104 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 ServiceProvider {
+class TracingServiceProvider : public mojo::ServiceProvider {
  public:
-  explicit TracingServiceProvider(InterfaceRequest<ServiceProvider> request)
+  explicit TracingServiceProvider(
+      mojo::InterfaceRequest<mojo::ServiceProvider> request)
       : binding_(this, request.Pass()) {}
   ~TracingServiceProvider() override {}
 
-  void ConnectToService(const String& service_name,
-                        ScopedMessagePipeHandle client_handle) override {
+  void ConnectToService(const mojo::String& service_name,
+                        mojo::ScopedMessagePipeHandle client_handle) override {
     if (service_name == tracing::TraceController::Name_) {
-      new TraceControllerImpl(
-          MakeRequest<tracing::TraceController>(client_handle.Pass()));
+      new mojo::TraceControllerImpl(
+          mojo::MakeRequest<tracing::TraceController>(client_handle.Pass()));
     }
   }
 
  private:
-  StrongBinding<ServiceProvider> binding_;
+  mojo::StrongBinding<mojo::ServiceProvider> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(TracingServiceProvider);
 };
 
 }  // namespace
 
 Context::Context() : application_manager_(this) {
   DCHECK(!base::MessageLoop::current());
 
   // By default assume that the local apps reside alongside the shell.
@@ skipping 59 matching lines @@
       new TaskRunners(base::MessageLoop::current()->message_loop_proxy()));
 
   // TODO(vtl): Probably these failures should be checked before |Init()|, and
   // this function simply shouldn't fail.
   if (!shell_file_root_.is_valid())
     return false;
   if (!ConfigureURLMappings(command_line, this))
     return false;
 
   // TODO(vtl): This should be MASTER, not NONE.
-  embedder::InitIPCSupport(
-      embedder::ProcessType::NONE, task_runners_->shell_runner(), this,
-      task_runners_->io_runner(), embedder::ScopedPlatformHandle());
+  mojo::embedder::InitIPCSupport(
+      mojo::embedder::ProcessType::NONE, task_runners_->shell_runner(), this,
+      task_runners_->io_runner(), mojo::embedder::ScopedPlatformHandle());
 
   scoped_ptr<NativeRunnerFactory> runner_factory;
   if (command_line.HasSwitch(switches::kEnableMultiprocess))
     runner_factory.reset(new OutOfProcessNativeRunnerFactory(this));
   else
     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);
 
-  ServiceProviderPtr tracing_service_provider_ptr;
-  new TracingServiceProvider(GetProxy(&tracing_service_provider_ptr));
+  mojo::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");
   DCHECK_EQ(base::MessageLoop::current()->task_runner(),
             task_runners_->shell_runner());
-  embedder::ShutdownIPCSupport();
+  mojo::embedder::ShutdownIPCSupport();
   // We'll quit when we get OnShutdownComplete().
   base::MessageLoop::current()->Run();
 }
 
 GURL Context::ResolveURL(const GURL& url) {
   return url_resolver_.ResolveMojoURL(url);
 }
 
 GURL Context::ResolveMappings(const GURL& url) {
   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) {
-  ServiceProviderPtr services;
-  ServiceProviderPtr exposed_services;
+  mojo::ServiceProviderPtr services;
+  mojo::ServiceProviderPtr exposed_services;
 
   app_urls_.insert(url);
   application_manager_.ConnectToApplication(
-      url, GURL(), GetProxy(&services), exposed_services.Pass(),
+      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
-}  // namespace mojo