Convert content ConnectionFilter to OnBindInterface

content/browser/dom_storage/local_storage_context_mojo.cc

 // Copyright 2016 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/local_storage_context_mojo.h"
 
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "components/leveldb/public/cpp/util.h"
 #include "components/leveldb/public/interfaces/leveldb.mojom.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
 #include "content/browser/dom_storage/dom_storage_database.h"
 #include "content/browser/dom_storage/dom_storage_task_runner.h"
 #include "content/browser/dom_storage/local_storage_database.pb.h"
 #include "content/browser/leveldb_wrapper_impl.h"
 #include "content/common/dom_storage/dom_storage_types.h"
 #include "content/public/browser/local_storage_usage_info.h"
 #include "services/file/public/interfaces/constants.mojom.h"
-#include "services/service_manager/public/cpp/connection.h"
 #include "services/service_manager/public/cpp/connector.h"
 #include "sql/connection.h"
 #include "third_party/leveldatabase/env_chromium.h"
 
 namespace content {
 
 // LevelDB database schema
 // =======================
 //
 // Version 1 (in sorted order):
@@ skipping 260 matching lines @@
   connection_state_ = CONNECTION_IN_PROGRESS;
   leveldb::mojom::LevelDBDatabaseAssociatedRequest request =
       MakeIsolatedRequest(&database_);
   OnDatabaseOpened(true, leveldb::mojom::DatabaseError::OK);
   return request;
 }
 
 void LocalStorageContextMojo::RunWhenConnected(base::OnceClosure callback) {
   // If we don't have a filesystem_connection_, we'll need to establish one.
   if (connection_state_ == NO_CONNECTION) {
-    CHECK(connector_);
-    file_service_connection_ = connector_->Connect(file::mojom::kServiceName);
     connection_state_ = CONNECTION_IN_PROGRESS;
-    file_service_connection_->AddConnectionCompletedClosure(
-        base::Bind(&LocalStorageContextMojo::OnUserServiceConnectionComplete,
-                   weak_ptr_factory_.GetWeakPtr()));
-    file_service_connection_->SetConnectionLostClosure(
-        base::Bind(&LocalStorageContextMojo::OnUserServiceConnectionError,
-                   weak_ptr_factory_.GetWeakPtr()));
-
     InitiateConnection();
   }
 
   if (connection_state_ == CONNECTION_IN_PROGRESS) {
     // Queue this OpenLocalStorage call for when we have a level db pointer.
     on_database_opened_callbacks_.push_back(std::move(callback));
     return;
   }
 
   std::move(callback).Run();
 }
 
-void LocalStorageContextMojo::OnUserServiceConnectionComplete() {
-  CHECK_EQ(service_manager::mojom::ConnectResult::SUCCEEDED,
-           file_service_connection_->GetResult());
-}
-
-void LocalStorageContextMojo::OnUserServiceConnectionError() {
-  CHECK(false);
-}
-
 void LocalStorageContextMojo::InitiateConnection(bool in_memory_only) {
   DCHECK_EQ(connection_state_, CONNECTION_IN_PROGRESS);
+  CHECK(connector_);
   if (!subdirectory_.empty() && !in_memory_only) {
     // We were given a subdirectory to write to. Get it and use a disk backed
     // database.
-    file_service_connection_->GetInterface(&file_system_);
+    connector_->BindInterface(file::mojom::kServiceName, &file_system_);
     file_system_->GetSubDirectory(
         subdirectory_.AsUTF8Unsafe(), MakeRequest(&directory_),
         base::Bind(&LocalStorageContextMojo::OnDirectoryOpened,
                    weak_ptr_factory_.GetWeakPtr()));
   } else {
     // We were not given a subdirectory. Use a memory backed database.
-    file_service_connection_->GetInterface(&leveldb_service_);
+    connector_->BindInterface(file::mojom::kServiceName, &leveldb_service_);
     leveldb_service_->OpenInMemory(
         MakeRequest(&database_),
         base::Bind(&LocalStorageContextMojo::OnDatabaseOpened,
                    weak_ptr_factory_.GetWeakPtr(), true));
   }
 }
 
 void LocalStorageContextMojo::OnDirectoryOpened(
     filesystem::mojom::FileError err) {
   if (err != filesystem::mojom::FileError::OK) {
     // We failed to open the directory; continue with startup so that we create
     // the |level_db_wrappers_|.
     UMA_HISTOGRAM_ENUMERATION("LocalStorageContext.DirectoryOpenError",
                               -static_cast<base::File::Error>(err),
                               -base::File::FILE_ERROR_MAX);
     UMA_HISTOGRAM_ENUMERATION(
         kStorageOpenHistogramName,
         static_cast<int>(LocalStorageOpenHistogram::DIRECTORY_OPEN_FAILED),
         static_cast<int>(LocalStorageOpenHistogram::MAX));
     OnDatabaseOpened(false, leveldb::mojom::DatabaseError::OK);
     return;
   }
 
   // Now that we have a directory, connect to the LevelDB service and get our
   // database.
-  file_service_connection_->GetInterface(&leveldb_service_);
+  connector_->BindInterface(file::mojom::kServiceName, &leveldb_service_);
   leveldb_service_->SetEnvironmentName("LevelDBEnv.LocalStorage");
 
   // We might still need to use the directory, so create a clone.
   filesystem::mojom::DirectoryPtr directory_clone;
   directory_->Clone(MakeRequest(&directory_clone));
 
   auto options = leveldb::mojom::OpenOptions::New();
   options->create_if_missing = true;
   leveldb_service_->OpenWithOptions(
       std::move(options), std::move(directory_clone), "leveldb",
@@ skipping 106 matching lines @@
     recreate_in_memory = true;
   } else if (tried_to_recreate_) {
     // Give up completely, run without any database.
     database_ = nullptr;
     OnConnectionFinished();
     return;
   }
 
   tried_to_recreate_ = true;
 
-  // Unit tests might not have a file_service_connection_, in which case there
-  // is nothing to retry.
-  if (!file_service_connection_) {
+  // Unit tests might not have a bound file_service_, in which case there is
+  // nothing to retry.
+  if (!file_system_.is_bound()) {
     database_ = nullptr;
     OnConnectionFinished();
     return;
   }
 
   // Close and destroy database, and try again.
   database_ = nullptr;
   if (directory_.is_bound()) {
     leveldb_service_->Destroy(
         std::move(directory_), "leveldb",
@@ skipping 79 matching lines @@
   for (const auto& info : usage) {
     url::Origin origin_candidate(info.origin);
     if (!origin_candidate.IsSameOriginWith(origin) &&
         origin_candidate.IsSamePhysicalOriginWith(origin))
       DeleteStorage(origin_candidate);
   }
   DeleteStorage(origin);
 }
 
 }  // namespace content