Move components\profile_service to services\user

content/browser/dom_storage/dom_storage_context_wrapper.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 "content/browser/dom_storage/dom_storage_context_wrapper.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/filesystem/public/interfaces/directory.mojom.h"
 #include "components/leveldb/public/interfaces/leveldb.mojom.h"
-#include "components/profile_service/public/cpp/constants.h"
-#include "components/profile_service/public/interfaces/profile.mojom.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_context_impl.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
 #include "content/browser/dom_storage/session_storage_namespace_impl.h"
 #include "content/browser/leveldb_wrapper_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "content/public/browser/session_storage_usage_info.h"
 #include "mojo/common/common_type_converters.h"
 #include "services/shell/public/cpp/connection.h"
 #include "services/shell/public/cpp/connector.h"
+#include "services/user/public/cpp/constants.h"
+#include "services/user/public/interfaces/user_service.mojom.h"
 
 namespace content {
 namespace {
 
 const char kLocalStorageDirectory[] = "Local Storage";
 const char kSessionStorageDirectory[] = "Session Storage";
 
 void InvokeLocalStorageUsageCallbackHelper(
       const DOMStorageContext::GetLocalStorageUsageCallback& callback,
       const std::vector<LocalStorageUsageInfo>* infos) {
@@ skipping 67 matching lines @@
 
   mojo::Connector* const connector_;
   const base::FilePath subdirectory_;
 
   enum ConnectionState {
     NO_CONNECTION,
     CONNECTION_IN_PROGRESS,
     CONNECTION_FINISHED
   } connection_state_;
 
-  std::unique_ptr<mojo::Connection> profile_app_connection_;
+  std::unique_ptr<mojo::Connection> user_service_connection_;
 
-  profile::ProfileServicePtr profile_service_;
+  user_service::mojom::UserServicePtr user_service_;
   filesystem::DirectoryPtr directory_;
 
   leveldb::LevelDBServicePtr leveldb_service_;
   leveldb::LevelDBDatabasePtr database_;
 
   std::vector<base::Closure> on_database_opened_callbacks_;
 
   base::WeakPtrFactory<MojoState> weak_ptr_factory_;
 };
 
 void DOMStorageContextWrapper::MojoState::OpenLocalStorage(
     const url::Origin& origin,
     mojom::LevelDBObserverPtr observer,
     mojom::LevelDBWrapperRequest request) {
   // If we don't have a filesystem_connection_, we'll need to establish one.
   if (connection_state_ == NO_CONNECTION) {
     CHECK(connector_);
-    profile_app_connection_ =
-        connector_->Connect(profile::kProfileMojoApplicationName);
+    user_service_connection_ =
+        connector_->Connect(user_service::kUserServiceName);
     connection_state_ = CONNECTION_IN_PROGRESS;
 
     if (!subdirectory_.empty()) {
       // We were given a subdirectory to write to. Get it and use a disk backed
       // database.
-      profile_app_connection_->GetInterface(&profile_service_);
-      profile_service_->GetSubDirectory(
+      user_service_connection_->GetInterface(&user_service_);
+      user_service_->GetSubDirectory(
           mojo::String::From(subdirectory_.AsUTF8Unsafe()),
           GetProxy(&directory_),
           base::Bind(&MojoState::OnDirectoryOpened,
                      weak_ptr_factory_.GetWeakPtr()));
     } else {
       // We were not given a subdirectory. Use a memory backed database.
-      profile_app_connection_->GetInterface(&leveldb_service_);
+      user_service_connection_->GetInterface(&leveldb_service_);
       leveldb_service_->OpenInMemory(
           GetProxy(&database_),
           base::Bind(&MojoState::OnDatabaseOpened,
                      weak_ptr_factory_.GetWeakPtr()));
     }
   }
 
   if (connection_state_ == CONNECTION_IN_PROGRESS) {
     // Queue this OpenLocalStorage call for when we have a level db pointer.
     on_database_opened_callbacks_.push_back(
         base::Bind(&MojoState::BindLocalStorage, weak_ptr_factory_.GetWeakPtr(),
                    origin, base::Passed(&observer), base::Passed(&request)));
     return;
   }
 
   BindLocalStorage(origin, std::move(observer), std::move(request));
 }
 
 void DOMStorageContextWrapper::MojoState::OnDirectoryOpened(
     filesystem::FileError err) {
   if (err != filesystem::FileError::OK) {
     // We failed to open the directory; continue with startup so that we create
     // the |level_db_wrappers_|.
     OnDatabaseOpened(leveldb::DatabaseError::IO_ERROR);
     return;
   }
 
   // Now that we have a directory, connect to the LevelDB service and get our
   // database.
-  profile_app_connection_->GetInterface(&leveldb_service_);
+  user_service_connection_->GetInterface(&leveldb_service_);
 
   leveldb_service_->Open(
       std::move(directory_), "leveldb", GetProxy(&database_),
       base::Bind(&MojoState::OnDatabaseOpened, weak_ptr_factory_.GetWeakPtr()));
 }
 
 void DOMStorageContextWrapper::MojoState::OnDatabaseOpened(
     leveldb::DatabaseError status) {
   if (status != leveldb::DatabaseError::OK) {
     // If we failed to open the database, reset the service object so we pass
     // null pointers to our wrappers.
     database_.reset();
     leveldb_service_.reset();
   }
 
-  // We no longer need the profile service; we've either transferred
+  // We no longer need the user service; we've either transferred
   // |directory_| to the leveldb service, or we got a file error and no more is
   // possible.
   directory_.reset();
-  profile_service_.reset();
+  user_service_.reset();
 
   // |leveldb_| should be known to either be valid or invalid by now. Run our
   // delayed bindings.
   connection_state_ = CONNECTION_FINISHED;
   for (size_t i = 0; i < on_database_opened_callbacks_.size(); ++i)
     on_database_opened_callbacks_[i].Run();
   on_database_opened_callbacks_.clear();
 }
 
 void DOMStorageContextWrapper::MojoState::BindLocalStorage(
@@ skipping 129 matching lines @@
 
 void DOMStorageContextWrapper::OpenLocalStorage(
     const url::Origin& origin,
     mojom::LevelDBObserverPtr observer,
     mojom::LevelDBWrapperRequest request) {
   mojo_state_->OpenLocalStorage(
       origin, std::move(observer), std::move(request));
 }
 
 }  // namespace content