Rename a bunch of Mojo Application stuff to reference Services.

content/browser/browser_context.cc

 // Copyright (c) 2012 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 "content/public/browser/browser_context.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <algorithm>
 #include <limits>
@@ skipping 14 matching lines @@
 #include "content/browser/loader/resource_dispatcher_host_impl.h"
 #include "content/browser/push_messaging/push_messaging_router.h"
 #include "content/browser/storage_partition_impl_map.h"
 #include "content/common/child_process_host_impl.h"
 #include "content/public/browser/blob_handle.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/common/content_switches.h"
-#include "content/public/common/mojo_shell_connection.h"
+#include "content/public/common/service_manager_connection.h"
 #include "content/public/common/service_names.h"
 #include "net/cookies/cookie_store.h"
 #include "net/ssl/channel_id_service.h"
 #include "net/ssl/channel_id_store.h"
 #include "net/url_request/url_request_context.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "services/file/file_service.h"
 #include "services/file/public/cpp/constants.h"
 #include "services/file/user_id_map.h"
 #include "services/shell/public/cpp/connection.h"
 #include "services/shell/public/cpp/connector.h"
 #include "services/shell/public/interfaces/service.mojom.h"
 #include "storage/browser/database/database_tracker.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 
 using base::UserDataAdapter;
 
 namespace content {
 
 namespace {
 
 base::LazyInstance<std::map<std::string, BrowserContext*>>
     g_user_id_to_context = LAZY_INSTANCE_INITIALIZER;
 
-class ShellUserIdHolder : public base::SupportsUserData::Data {
+class ServiceUserIdHolder : public base::SupportsUserData::Data {
  public:
-  explicit ShellUserIdHolder(const std::string& user_id) : user_id_(user_id) {}
-  ~ShellUserIdHolder() override {}
+  explicit ServiceUserIdHolder(const std::string& user_id)
+      : user_id_(user_id) {}
+  ~ServiceUserIdHolder() override {}
 
   const std::string& user_id() const { return user_id_; }
 
  private:
   std::string user_id_;
 
-  DISALLOW_COPY_AND_ASSIGN(ShellUserIdHolder);
+  DISALLOW_COPY_AND_ASSIGN(ServiceUserIdHolder);
 };
 
 // Key names on BrowserContext.
 const char kDownloadManagerKeyName[] = "download_manager";
-const char kMojoShellConnection[] = "mojo-shell-connection";
 const char kMojoWasInitialized[] = "mojo-was-initialized";
-const char kMojoShellUserId[] = "mojo-shell-user-id";
+const char kServiceManagerConnection[] = "service-manager-connection";
+const char kServiceUserId[] = "service-user-id";
 const char kStoragePartitionMapKeyName[] = "content_storage_partition_map";
 
 #if defined(OS_CHROMEOS)
 const char kMountPointsKey[] = "mount_points";
 #endif  // defined(OS_CHROMEOS)
 
 void RemoveBrowserContextFromUserIdMap(BrowserContext* browser_context) {
-  ShellUserIdHolder* holder = static_cast<ShellUserIdHolder*>(
-      browser_context->GetUserData(kMojoShellUserId));
+  ServiceUserIdHolder* holder = static_cast<ServiceUserIdHolder*>(
+      browser_context->GetUserData(kServiceUserId));
   if (holder) {
     auto it = g_user_id_to_context.Get().find(holder->user_id());
     if (it != g_user_id_to_context.Get().end())
       g_user_id_to_context.Get().erase(it);
   }
 }
 
 StoragePartitionImplMap* GetStoragePartitionMap(
     BrowserContext* browser_context) {
   StoragePartitionImplMap* partition_map =
@@ skipping 42 matching lines @@
   wrapper->process_manager()->Shutdown();
 }
 
 void SetDownloadManager(BrowserContext* context,
                         content::DownloadManager* download_manager) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(download_manager);
   context->SetUserData(kDownloadManagerKeyName, download_manager);
 }
 
-class BrowserContextShellConnectionHolder
+class BrowserContextServiceManagerConnectionHolder
     : public base::SupportsUserData::Data {
  public:
-  BrowserContextShellConnectionHolder(
+   BrowserContextServiceManagerConnectionHolder(
       std::unique_ptr<shell::Connection> connection,
       shell::mojom::ServiceRequest request)
       : root_connection_(std::move(connection)),
-        shell_connection_(MojoShellConnection::Create(
+        service_manager_connection_(ServiceManagerConnection::Create(
             std::move(request),
             BrowserThread::GetTaskRunnerForThread(BrowserThread::IO))) {}
-  ~BrowserContextShellConnectionHolder() override {}
+  ~BrowserContextServiceManagerConnectionHolder() override {}
 
-  MojoShellConnection* shell_connection() { return shell_connection_.get(); }
+  ServiceManagerConnection* service_manager_connection() {
+    return service_manager_connection_.get();
+  }
 
  private:
   std::unique_ptr<shell::Connection> root_connection_;
-  std::unique_ptr<MojoShellConnection> shell_connection_;
+  std::unique_ptr<ServiceManagerConnection> service_manager_connection_;
 
-  DISALLOW_COPY_AND_ASSIGN(BrowserContextShellConnectionHolder);
+  DISALLOW_COPY_AND_ASSIGN(BrowserContextServiceManagerConnectionHolder);
 };
 
 }  // namespace
 
 // static
 void BrowserContext::AsyncObliterateStoragePartition(
     BrowserContext* browser_context,
     const GURL& site,
     const base::Closure& on_gc_required) {
   GetStoragePartitionMap(browser_context)->AsyncObliterate(site,
@@ skipping 221 matching lines @@
   SetDownloadManager(browser_context, download_manager);
 }
 
 // static
 void BrowserContext::Initialize(
     BrowserContext* browser_context,
     const base::FilePath& path) {
 
   std::string new_id;
   if (GetContentClient() && GetContentClient()->browser()) {
-    new_id = GetContentClient()->browser()->GetShellUserIdForBrowserContext(
+    new_id = GetContentClient()->browser()->GetServiceUserIdForBrowserContext(
         browser_context);
   } else {
     // Some test scenarios initialize a BrowserContext without a content client.
     new_id = base::GenerateGUID();
   }
 
-  ShellUserIdHolder* holder = static_cast<ShellUserIdHolder*>(
-      browser_context->GetUserData(kMojoShellUserId));
+  ServiceUserIdHolder* holder = static_cast<ServiceUserIdHolder*>(
+      browser_context->GetUserData(kServiceUserId));
   if (holder)
-    file::ForgetShellUserIdUserDirAssociation(holder->user_id());
-  file::AssociateShellUserIdWithUserDir(new_id, path);
+    file::ForgetServiceUserIdUserDirAssociation(holder->user_id());
+  file::AssociateServiceUserIdWithUserDir(new_id, path);
   RemoveBrowserContextFromUserIdMap(browser_context);
   g_user_id_to_context.Get()[new_id] = browser_context;
-  browser_context->SetUserData(kMojoShellUserId,
-                               new ShellUserIdHolder(new_id));
+  browser_context->SetUserData(kServiceUserId,
+                               new ServiceUserIdHolder(new_id));
 
   browser_context->SetUserData(kMojoWasInitialized,
                                new base::SupportsUserData::Data);
 
-  MojoShellConnection* shell = MojoShellConnection::GetForProcess();
-  if (shell && base::MessageLoop::current()) {
+  ServiceManagerConnection* service_manager_connection =
+      ServiceManagerConnection::GetForProcess();
+  if (service_manager_connection && base::MessageLoop::current()) {
     // NOTE: Many unit tests create a TestBrowserContext without initializing
-    // Mojo or the global Mojo shell connection.
+    // Mojo or the global service manager connection.
 
     shell::mojom::ServicePtr service;
     shell::mojom::ServiceRequest service_request = mojo::GetProxy(&service);
 
     shell::mojom::PIDReceiverPtr pid_receiver;
     shell::Connector::ConnectParams params(
-        shell::Identity(kBrowserMojoApplicationName, new_id));
+        shell::Identity(kBrowserServiceName, new_id));
     params.set_client_process_connection(std::move(service),
                                          mojo::GetProxy(&pid_receiver));
     pid_receiver->SetPID(base::GetCurrentProcId());
 
-    BrowserContextShellConnectionHolder* connection_holder =
-        new BrowserContextShellConnectionHolder(
-          shell->GetConnector()->Connect(&params),
-          std::move(service_request));
-    browser_context->SetUserData(kMojoShellConnection, connection_holder);
+    BrowserContextServiceManagerConnectionHolder* connection_holder =
+        new BrowserContextServiceManagerConnectionHolder(
+            service_manager_connection->GetConnector()->Connect(&params),
+            std::move(service_request));
+    browser_context->SetUserData(kServiceManagerConnection, connection_holder);
 
-    MojoShellConnection* connection = connection_holder->shell_connection();
+    ServiceManagerConnection* connection =
+        connection_holder->service_manager_connection();
     connection->Start();
 
     // New embedded service factories should be added to |connection| here.
 
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kMojoLocalStorage)) {
-      MojoApplicationInfo info;
-      info.application_factory =
+      ServiceInfo info;
+      info.factory =
           base::Bind(&file::CreateFileService,
                      BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE),
                      BrowserThread::GetTaskRunnerForThread(BrowserThread::DB));
       connection->AddEmbeddedService(file::kFileServiceName, info);
     }
   }
 }
 
 // static
-const std::string& BrowserContext::GetShellUserIdFor(
+const std::string& BrowserContext::GetServiceUserIdFor(
     BrowserContext* browser_context) {
   CHECK(browser_context->GetUserData(kMojoWasInitialized))
       << "Attempting to get the mojo user id for a BrowserContext that was "
       << "never Initialize()ed.";
 
-  ShellUserIdHolder* holder = static_cast<ShellUserIdHolder*>(
-      browser_context->GetUserData(kMojoShellUserId));
+  ServiceUserIdHolder* holder = static_cast<ServiceUserIdHolder*>(
+      browser_context->GetUserData(kServiceUserId));
   return holder->user_id();
 }
 
 // static
-BrowserContext* BrowserContext::GetBrowserContextForShellUserId(
+BrowserContext* BrowserContext::GetBrowserContextForServiceUserId(
     const std::string& user_id) {
   auto it = g_user_id_to_context.Get().find(user_id);
   return it != g_user_id_to_context.Get().end() ? it->second : nullptr;
 }
 
 // static
-shell::Connector* BrowserContext::GetShellConnectorFor(
+shell::Connector* BrowserContext::GetConnectorFor(
     BrowserContext* browser_context) {
-  MojoShellConnection* connection = GetMojoShellConnectionFor(browser_context);
+  ServiceManagerConnection* connection =
+      GetServiceManagerConnectionFor(browser_context);
   return connection ? connection->GetConnector() : nullptr;
 }
 
 // static
-MojoShellConnection* BrowserContext::GetMojoShellConnectionFor(
+ServiceManagerConnection* BrowserContext::GetServiceManagerConnectionFor(
     BrowserContext* browser_context) {
-  BrowserContextShellConnectionHolder* connection_holder =
-      static_cast<BrowserContextShellConnectionHolder*>(
-          browser_context->GetUserData(kMojoShellConnection));
-  return connection_holder ? connection_holder->shell_connection() : nullptr;
+  BrowserContextServiceManagerConnectionHolder* connection_holder =
+      static_cast<BrowserContextServiceManagerConnectionHolder*>(
+          browser_context->GetUserData(kServiceManagerConnection));
+  return connection_holder ? connection_holder->service_manager_connection()
+                           : nullptr;
 }
 
 BrowserContext::~BrowserContext() {
   CHECK(GetUserData(kMojoWasInitialized))
       << "Attempting to destroy a BrowserContext that never called "
       << "Initialize()";
 
   DCHECK(!GetUserData(kStoragePartitionMapKeyName))
       << "StoragePartitionMap is not shut down properly";
 
   RemoveBrowserContextFromUserIdMap(this);
 
   if (GetUserData(kDownloadManagerKeyName))
     GetDownloadManager(this)->Shutdown();
 }
 
 void BrowserContext::ShutdownStoragePartitions() {
   if (GetUserData(kStoragePartitionMapKeyName))
     RemoveUserData(kStoragePartitionMapKeyName);
 }
 
 }  // namespace content