Use ShellClientFactory interface to load mojo:profile

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/mojo_app_connection.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"
 
 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 29 matching lines @@
       FROM_HERE, base::Bind(&InvokeSessionStorageUsageCallbackHelper, callback,
                             base::Owned(infos)));
 }
 
 }  // namespace
 
 // Used for mojo-based LocalStorage implementation (behind --mojo-local-storage
 // for now).
 class DOMStorageContextWrapper::MojoState {
  public:
-  MojoState(const std::string& mojo_user_id, const base::FilePath& subdirectory)
-      : mojo_user_id_(mojo_user_id),
+  MojoState(mojo::Connector* connector, const base::FilePath& subdirectory)
+      : connector_(connector),
         subdirectory_(subdirectory),
         connection_state_(NO_CONNECTION),
         weak_ptr_factory_(this) {}
 
   void OpenLocalStorage(const url::Origin& origin,
                         mojom::LevelDBObserverPtr observer,
                         mojom::LevelDBWrapperRequest request);
 
  private:
   void OnLevelDDWrapperHasNoBindings(const url::Origin& origin) {
     DCHECK(level_db_wrappers_.find(origin) != level_db_wrappers_.end());
     level_db_wrappers_.erase(origin);
   }
 
   // Part of our asynchronous directory opening called from OpenLocalStorage().
   void OnDirectoryOpened(filesystem::FileError err);
   void OnDatabaseOpened(leveldb::DatabaseError status);
 
   // The (possibly delayed) implementation of OpenLocalStorage(). Can be called
   // directly from that function, or through |on_database_open_callbacks_|.
   void BindLocalStorage(const url::Origin& origin,
                         mojom::LevelDBObserverPtr observer,
                         mojom::LevelDBWrapperRequest request);
 
   // Maps between an origin and its prefixed LevelDB view.
   std::map<url::Origin, std::unique_ptr<LevelDBWrapperImpl>> level_db_wrappers_;
 
-  std::string mojo_user_id_;
-  base::FilePath subdirectory_;
+  mojo::Connector* const connector_;
+  const base::FilePath subdirectory_;
 
   enum ConnectionState {
     NO_CONNECTION,
     CONNECTION_IN_PROGRESS,
     CONNECTION_FINISHED
   } connection_state_;
 
-  std::unique_ptr<MojoAppConnection> profile_app_connection_;
+  std::unique_ptr<mojo::Connection> profile_app_connection_;
+
   profile::ProfileServicePtr profile_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) {
-    profile_app_connection_ = MojoAppConnection::Create(
-        mojo_user_id_, "mojo:profile", kBrowserMojoAppUrl);
-
+    CHECK(connector_);
+    profile_app_connection_ =
+        connector_->Connect(profile::kProfileMojoApplicationName);
     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(
           mojo::String::From(subdirectory_.AsUTF8Unsafe()),
           GetProxy(&directory_),
           base::Bind(&MojoState::OnDirectoryOpened,
@@ skipping 72 matching lines @@
         base::Bind(&MojoState::OnLevelDDWrapperHasNoBindings,
                    base::Unretained(this), origin)));
     found = level_db_wrappers_.find(origin);
   }
 
   found->second->Bind(std::move(request));
   found->second->AddObserver(std::move(observer));
 }
 
 DOMStorageContextWrapper::DOMStorageContextWrapper(
-    const std::string& mojo_user_id,
+    mojo::Connector* connector,
     const base::FilePath& profile_path,
     const base::FilePath& local_partition_path,
     storage::SpecialStoragePolicy* special_storage_policy) {
   base::FilePath storage_dir;
   if (!profile_path.empty())
     storage_dir = local_partition_path.AppendASCII(kLocalStorageDirectory);
-  mojo_state_.reset(new MojoState(mojo_user_id, storage_dir));
+  mojo_state_.reset(new MojoState(connector, storage_dir));
 
   base::FilePath data_path;
   if (!profile_path.empty())
     data_path = profile_path.Append(local_partition_path);
   base::SequencedWorkerPool* worker_pool = BrowserThread::GetBlockingPool();
   context_ = new DOMStorageContextImpl(
       data_path.empty() ? data_path
                         : data_path.AppendASCII(kLocalStorageDirectory),
       data_path.empty() ? data_path
                         : data_path.AppendASCII(kSessionStorageDirectory),
@@ skipping 93 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