Move //mojo/shell to //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 "mojo/shell/context.h"
+#include "shell/context.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/strings/string_split.h"
 #include "build/build_config.h"
 #include "mojo/application_manager/application_loader.h"
 #include "mojo/application_manager/application_manager.h"
 #include "mojo/application_manager/background_shell_application_loader.h"
 #include "mojo/common/tracing_impl.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/application/application_delegate.h"
 #include "mojo/public/cpp/application/application_impl.h"
-#include "mojo/shell/dynamic_application_loader.h"
-#include "mojo/shell/external_application_listener.h"
-#include "mojo/shell/in_process_dynamic_service_runner.h"
-#include "mojo/shell/out_of_process_dynamic_service_runner.h"
-#include "mojo/shell/switches.h"
-#include "mojo/shell/ui_application_loader_android.h"
 #include "mojo/spy/spy.h"
 #include "services/tracing/tracing.mojom.h"
+#include "shell/dynamic_application_loader.h"
+#include "shell/external_application_listener.h"
+#include "shell/in_process_dynamic_service_runner.h"
+#include "shell/out_of_process_dynamic_service_runner.h"
+#include "shell/switches.h"
+#include "shell/ui_application_loader_android.h"
 #include "url/gurl.h"
 
 #if defined(OS_ANDROID)
-#include "mojo/shell/android/android_handler_loader.h"
-#include "mojo/shell/network_application_loader.h"
 #include "services/gles2/gpu_impl.h"
 #include "services/native_viewport/native_viewport_impl.h"
+#include "shell/android/android_handler_loader.h"
+#include "shell/network_application_loader.h"
 #endif  // defined(OS_ANDROID)
 
 namespace mojo {
 namespace shell {
 namespace {
 
 // These mojo: URLs are loaded directly from the local filesystem. They
 // correspond to shared libraries bundled alongside the mojo_shell.
 const char* kLocalMojoURLs[] = {
     "mojo:network_service",
 };
 
 // Used to ensure we only init once.
 class Setup {
  public:
   Setup() {
     embedder::Init(scoped_ptr<mojo::embedder::PlatformSupport>(
         new mojo::embedder::SimplePlatformSupport()));
   }
 
-  ~Setup() {
-  }
+  ~Setup() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(Setup);
 };
 
 static base::LazyInstance<Setup>::Leaky setup = LAZY_INSTANCE_INITIALIZER;
 
 void InitContentHandlers(DynamicApplicationLoader* loader,
                          base::CommandLine* command_line) {
   // Default content handlers.
   loader->RegisterContentHandler("application/pdf", GURL("mojo:pdf_viewer"));
   loader->RegisterContentHandler("image/png", GURL("mojo:png_viewer"));
   loader->RegisterContentHandler("text/html", GURL("mojo:html_viewer"));
 
   // Command-line-specified content handlers.
-  std::string handlers_spec = command_line->GetSwitchValueASCII(
-      switches::kContentHandlers);
+  std::string handlers_spec =
+      command_line->GetSwitchValueASCII(switches::kContentHandlers);
   if (handlers_spec.empty())
     return;
 
   std::vector<std::string> parts;
   base::SplitString(handlers_spec, ',', &parts);
   if (parts.size() % 2 != 0) {
     LOG(ERROR) << "Invalid value for switch " << switches::kContentHandlers
                << ": must be a comma-separated list of mimetype/url pairs.";
     return;
   }
@@ skipping 134 matching lines @@
     runner_factory.reset(new OutOfProcessDynamicServiceRunnerFactory());
   else
     runner_factory.reset(new InProcessDynamicServiceRunnerFactory());
 
   DynamicApplicationLoader* dynamic_application_loader =
       new DynamicApplicationLoader(this, runner_factory.Pass());
   InitContentHandlers(dynamic_application_loader, command_line);
   application_manager_.set_default_loader(
       scoped_ptr<ApplicationLoader>(dynamic_application_loader));
 
-  // The native viewport service synchronously waits for certain messages. If we
-  // don't run it on its own thread we can easily deadlock. Long term native
-  // viewport should run its own process so that this isn't an issue.
+// The native viewport service synchronously waits for certain messages. If we
+// don't run it on its own thread we can easily deadlock. Long term native
+// viewport should run its own process so that this isn't an issue.
 #if defined(OS_ANDROID)
   application_manager_.SetLoaderForURL(
       scoped_ptr<ApplicationLoader>(new UIApplicationLoader(
           scoped_ptr<ApplicationLoader>(new NativeViewportApplicationLoader()),
           this)),
       GURL("mojo:native_viewport_service"));
 #endif
 
   if (command_line->HasSwitch(switches::kSpy)) {
     spy_.reset(
         new mojo::Spy(&application_manager_,
                       command_line->GetSwitchValueASCII(switches::kSpy)));
     // TODO(cpu): the spy can snoop, but can't tell anybody until
     // the Spy::WebSocketDelegate is implemented. In the original repo this
     // was implemented by src\mojo\spy\websocket_server.h and .cc.
   }
 
 #if defined(OS_ANDROID)
   // On android, the network service is bundled with the shell because the
   // network stack depends on the android runtime.
   {
     scoped_ptr<BackgroundShellApplicationLoader> loader(
         new BackgroundShellApplicationLoader(
             scoped_ptr<ApplicationLoader>(new NetworkApplicationLoader()),
-            "network_service",
-            base::MessageLoop::TYPE_IO));
+            "network_service", base::MessageLoop::TYPE_IO));
     application_manager_.SetLoaderForURL(loader.Pass(),
                                          GURL("mojo:network_service"));
   }
   {
     scoped_ptr<BackgroundShellApplicationLoader> loader(
         new BackgroundShellApplicationLoader(
             scoped_ptr<ApplicationLoader>(new AndroidHandlerLoader()),
             "android_handler", base::MessageLoop::TYPE_DEFAULT));
     application_manager_.SetLoaderForURL(loader.Pass(),
                                          GURL("mojo:android_handler"));
@@ skipping 29 matching lines @@
   BindToProxy(sp, &spp);
 
   app_urls_.insert(url);
   application_manager_.ConnectToApplication(url, GURL(), spp.Pass());
 }
 
 ScopedMessagePipeHandle Context::ConnectToServiceByName(
     const GURL& application_url,
     const std::string& service_name) {
   app_urls_.insert(application_url);
-  return application_manager_.ConnectToServiceByName(
-      application_url, service_name).Pass();
+  return application_manager_.ConnectToServiceByName(application_url,
+                                                     service_name).Pass();
 }
 
 }  // namespace shell
 }  // namespace mojo