ShellClient -> Service

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 22 matching lines @@
 #include "content/public/browser/site_instance.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/mojo_shell_connection.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/shell/public/cpp/connection.h"
 #include "services/shell/public/cpp/connector.h"
-#include "services/shell/public/interfaces/shell_client.mojom.h"
+#include "services/shell/public/interfaces/service.mojom.h"
 #include "services/user/public/cpp/constants.h"
 #include "services/user/user_id_map.h"
 #include "services/user/user_shell_client.h"
 #include "storage/browser/database/database_tracker.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 
 using base::UserDataAdapter;
 
 namespace content {
 
@@ skipping 89 matching lines @@
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK(download_manager);
   context->SetUserData(kDownloadManagerKeyName, download_manager);
 }
 
 class BrowserContextShellConnectionHolder
     : public base::SupportsUserData::Data {
  public:
   BrowserContextShellConnectionHolder(
       std::unique_ptr<shell::Connection> connection,
-      shell::mojom::ShellClientRequest request)
+      shell::mojom::ServiceRequest request)
       : root_connection_(std::move(connection)),
         shell_connection_(MojoShellConnection::Create(std::move(request))) {}
   ~BrowserContextShellConnectionHolder() override {}
 
   MojoShellConnection* shell_connection() { return shell_connection_.get(); }
 
  private:
   std::unique_ptr<shell::Connection> root_connection_;
   std::unique_ptr<MojoShellConnection> shell_connection_;
 
@@ skipping 245 matching lines @@
                                new ShellUserIdHolder(new_id));
 
   browser_context->SetUserData(kMojoWasInitialized,
                                new base::SupportsUserData::Data);
 
   MojoShellConnection* shell = MojoShellConnection::GetForProcess();
   if (shell && base::MessageLoop::current()) {
     // NOTE: Many unit tests create a TestBrowserContext without initializing
     // Mojo or the global Mojo shell connection.
 
-    shell::mojom::ShellClientPtr shell_client;
-    shell::mojom::ShellClientRequest shell_client_request =
-        mojo::GetProxy(&shell_client);
+    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));
-    params.set_client_process_connection(std::move(shell_client),
+    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(shell_client_request));
+          std::move(service_request));
     browser_context->SetUserData(kMojoShellConnection, connection_holder);
 
     MojoShellConnection* connection = connection_holder->shell_connection();
 
     // New embedded service factories should be added to |connection| here.
 
     if (base::CommandLine::ForCurrentProcess()->HasSwitch(
             switches::kMojoLocalStorage)) {
       MojoApplicationInfo info;
       info.application_factory = base::Bind(
-          &user_service::CreateUserShellClient,
+          &user_service::CreateUserService,
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE),
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::DB));
       connection->AddEmbeddedService(user_service::kUserServiceName, info);
     }
   }
 }
 
 // static
 const std::string& BrowserContext::GetShellUserIdFor(
     BrowserContext* browser_context) {
@@ skipping 29 matching lines @@
       << "Attempting to destroy a BrowserContext that never called "
       << "Initialize()";
 
   RemoveBrowserContextFromUserIdMap(this);
 
   if (GetUserData(kDownloadManagerKeyName))
     GetDownloadManager(this)->Shutdown();
 }
 
 }  // namespace content