Move mojo\shell to services\shell

services/shell/shell.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/shell.h"
+#include "services/shell/shell.h"
 
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/guid.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/process/process.h"
 #include "base/process/process_handle.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/trace_event/trace_event.h"
 #include "mojo/common/url_type_converters.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
-#include "mojo/shell/connect_util.h"
-#include "mojo/shell/public/cpp/connector.h"
-#include "mojo/shell/public/cpp/names.h"
-#include "mojo/shell/public/cpp/shell_connection.h"
-#include "mojo/shell/public/interfaces/connector.mojom.h"
-#include "mojo/shell/public/interfaces/shell.mojom.h"
-#include "mojo/shell/public/interfaces/shell_client.mojom.h"
 #include "mojo/util/filename_util.h"
+#include "services/shell/connect_util.h"
+#include "services/shell/public/cpp/connector.h"
+#include "services/shell/public/cpp/names.h"
+#include "services/shell/public/cpp/shell_connection.h"
+#include "services/shell/public/interfaces/connector.mojom.h"
+#include "services/shell/public/interfaces/shell.mojom.h"
+#include "services/shell/public/interfaces/shell_client.mojom.h"
 #include "url/gurl.h"
 
 namespace mojo {
 namespace shell {
 namespace {
 const char kCatalogName[] = "mojo:catalog";
 const char kShellName[] = "mojo:shell";
 const char kCapabilityClass_UserID[] = "user_id";
 const char kCapabilityClass_ClientProcess[] = "client_process";
 const char kCapabilityClass_InstanceName[] = "instance_name";
@@ skipping 60 matching lines @@
 }
 
 // Encapsulates a connection to an instance of an application, tracked by the
 // shell's Shell.
 class Shell::Instance : public mojom::Connector,
                         public mojom::PIDReceiver,
                         public ShellClient,
                         public InterfaceFactory<mojom::Shell>,
                         public mojom::Shell {
  public:
-  Instance(mojo::shell::Shell* shell,
+  Instance(shell::Shell* shell,
            const Identity& identity,
            const CapabilitySpec& capability_spec)
     : shell_(shell),
       id_(GenerateUniqueID()),
       identity_(identity),
       capability_spec_(capability_spec),
       allow_any_application_(capability_spec.required.count("*") == 1),
       pid_receiver_binding_(this),
       weak_factory_(this) {
     if (identity_.name() == kShellName ||
@@ skipping 65 matching lines @@
   }
 
   void StartWithFilePath(const base::FilePath& path) {
     CHECK(!shell_client_);
     scoped_ptr<NativeRunner> runner =
         shell_->native_runner_factory_->Create(path);
     bool start_sandboxed = false;
     mojom::ShellClientPtr client = runner->Start(
         path, identity_, start_sandboxed,
         base::Bind(&Instance::PIDAvailable, weak_factory_.GetWeakPtr()),
-        base::Bind(&mojo::shell::Shell::CleanupRunner,
+        base::Bind(&shell::Shell::CleanupRunner,
                    shell_->weak_ptr_factory_.GetWeakPtr(), runner.get()));
     shell_->native_runners_.push_back(std::move(runner));
     StartWithClient(std::move(client));
   }
 
   mojom::InstanceInfoPtr CreateInstanceInfo() const {
     mojom::InstanceInfoPtr info(mojom::InstanceInfo::New());
     info->id = id_;
     info->identity = mojom::Identity::From(identity_);
     info->pid = pid_;
@@ skipping 163 matching lines @@
     ++id;
     CHECK_NE(mojom::kInvalidInstanceID, id);
     return id;
   }
 
   void PIDAvailable(base::ProcessId pid) {
     pid_ = pid;
     shell_->NotifyPIDAvailable(id_, pid_);
   }
 
-  void OnShellClientLost(base::WeakPtr<mojo::shell::Shell> shell) {
+  void OnShellClientLost(base::WeakPtr<shell::Shell> shell) {
     shell_client_.reset();
     OnConnectionLost(shell);
   }
 
-  void OnConnectionLost(base::WeakPtr<mojo::shell::Shell> shell) {
+  void OnConnectionLost(base::WeakPtr<shell::Shell> shell) {
     // Any time a Connector is lost or we lose the ShellClient connection, it
     // may have been the last pipe using this Instance. If so, clean up.
     if (shell && connectors_.empty() && !shell_client_) {
       // Deletes |this|.
       shell->OnInstanceError(this);
     }
   }
 
   void OnInitializeResponse(mojom::ConnectorRequest connector_request) {
     if (connector_request.is_pending()) {
       connectors_.AddBinding(this, std::move(connector_request));
       connectors_.set_connection_error_handler(
           base::Bind(&Instance::OnConnectionLost, base::Unretained(this),
                      shell_->GetWeakPtr()));
     }
   }
 
-  mojo::shell::Shell* const shell_;
+  shell::Shell* const shell_;
 
   // An id that identifies this instance. Distinct from pid, as a single process
   // may vend multiple application instances, and this object may exist before a
   // process is launched.
   const uint32_t id_;
   const Identity identity_;
   const CapabilitySpec capability_spec_;
   const bool allow_any_application_;
   mojom::ShellClientPtr shell_client_;
   Binding<mojom::PIDReceiver> pid_receiver_binding_;
@@ skipping 102 matching lines @@
 
 void Shell::InitCatalog(mojom::ShellClientPtr catalog) {
   Instance* instance = CreateInstance(CreateShellIdentity(),
                                       CreateCatalogIdentity(),
                                       CapabilitySpec());
   singletons_.insert(kCatalogName);
   instance->StartWithClient(std::move(catalog));
 
   // TODO(beng): this doesn't work anymore.
   // Seed the catalog with manifest info for the shell & catalog.
-  mojo::shell::mojom::ShellResolverPtr resolver;
+  shell::mojom::ShellResolverPtr resolver;
   shell_connection_->connector()->ConnectToInterface(kCatalogName, &resolver);
   resolver->ResolveMojoName(kCatalogName, base::Bind(&EmptyResolverCallback));
   resolver->ResolveMojoName(kShellName, base::Bind(&EmptyResolverCallback));
 }
 
 void Shell::TerminateShellConnections() {
   Instance* instance = GetExistingInstance(CreateShellIdentity());
   DCHECK(instance);
   OnInstanceError(instance);
 }
@@ skipping 243 matching lines @@
   for (auto it = native_runners_.begin(); it != native_runners_.end(); ++it) {
     if (it->get() == runner) {
       native_runners_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace shell
 }  // namespace mojo