[IndexedDB] Closing mojo connections when renderer quits

content/browser/indexed_db/indexed_db_callbacks.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/browser/indexed_db/indexed_db_callbacks.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <utility>
@@ skipping 63 matching lines @@
     swap(mojo_value->value->bits, value->bits);
   ConvertBlobInfo(value->blob_info, &mojo_value->value->blob_or_file_info);
   return mojo_value;
 }
 
 }  // namespace
 
 class IndexedDBCallbacks::IOThreadHelper {
  public:
   IOThreadHelper(CallbacksAssociatedPtrInfo callbacks_info,
-                 scoped_refptr<IndexedDBDispatcherHost> dispatcher_host);
+                 IndexedDBDispatcherHost* dispatcher_host);
   ~IOThreadHelper();
 
   void SendError(const IndexedDBDatabaseError& error);
   void SendSuccessStringList(const std::vector<base::string16>& value);
   void SendBlocked(int64_t existing_version);
   void SendUpgradeNeeded(std::unique_ptr<DatabaseImpl> database,
                          int64_t old_version,
                          blink::WebIDBDataLoss data_loss,
                          const std::string& data_loss_message,
                          const content::IndexedDBDatabaseMetadata& metadata);
@@ skipping 23 matching lines @@
   void SendSuccessInteger(int64_t value);
   void SendSuccess();
 
   std::string CreateBlobData(const IndexedDBBlobInfo& blob_info);
   bool CreateAllBlobs(
       const std::vector<IndexedDBBlobInfo>& blob_info,
       std::vector<::indexed_db::mojom::BlobInfoPtr>* blob_or_file_info);
   void OnConnectionError();
 
  private:
-  scoped_refptr<IndexedDBDispatcherHost> dispatcher_host_;
+  base::WeakPtr<IndexedDBDispatcherHost> dispatcher_host_;
   ::indexed_db::mojom::CallbacksAssociatedPtr callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(IOThreadHelper);
 };
 
 // static
 ::indexed_db::mojom::ValuePtr IndexedDBCallbacks::ConvertAndEraseValue(
     IndexedDBValue* value) {
   auto mojo_value = ::indexed_db::mojom::Value::New();
   if (!value->empty())
     swap(mojo_value->bits, value->bits);
   ConvertBlobInfo(value->blob_info, &mojo_value->blob_or_file_info);
   return mojo_value;
 }
 
 IndexedDBCallbacks::IndexedDBCallbacks(
-    scoped_refptr<IndexedDBDispatcherHost> dispatcher_host,
+    IndexedDBDispatcherHost* dispatcher_host,
     const url::Origin& origin,
     ::indexed_db::mojom::CallbacksAssociatedPtrInfo callbacks_info)
-    : dispatcher_host_(std::move(dispatcher_host)),
+    : dispatcher_host_(dispatcher_host),
       origin_(origin),
       data_loss_(blink::WebIDBDataLossNone),
       sent_blocked_(false),
       io_helper_(
           new IOThreadHelper(std::move(callbacks_info), dispatcher_host_)) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   thread_checker_.DetachFromThread();
 }
 
 IndexedDBCallbacks::~IndexedDBCallbacks() {
@@ skipping 274 matching lines @@
   dispatcher_host_ = nullptr;
 }
 
 void IndexedDBCallbacks::SetConnectionOpenStartTime(
     const base::TimeTicks& start_time) {
   connection_open_start_time_ = start_time;
 }
 
 IndexedDBCallbacks::IOThreadHelper::IOThreadHelper(
     CallbacksAssociatedPtrInfo callbacks_info,
-    scoped_refptr<IndexedDBDispatcherHost> dispatcher_host)
-    : dispatcher_host_(std::move(dispatcher_host)) {
+    IndexedDBDispatcherHost* dispatcher_host)
+    : dispatcher_host_(dispatcher_host->AsWeakPtr()) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   if (callbacks_info.is_valid()) {
     callbacks_.Bind(std::move(callbacks_info));
     callbacks_.set_connection_error_handler(
         base::Bind(&IOThreadHelper::OnConnectionError, base::Unretained(this)));
   }
 }
 
 IndexedDBCallbacks::IOThreadHelper::~IOThreadHelper() {}
 
 void IndexedDBCallbacks::IOThreadHelper::SendError(
     const IndexedDBDatabaseError& error) {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (callbacks_)
     callbacks_->Error(error.code(), error.message());
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessStringList(
     const std::vector<base::string16>& value) {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (callbacks_)
     callbacks_->SuccessStringList(value);
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendBlocked(int64_t existing_version) {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (callbacks_)
     callbacks_->Blocked(existing_version);
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendUpgradeNeeded(
     std::unique_ptr<DatabaseImpl> database,
     int64_t old_version,
     blink::WebIDBDataLoss data_loss,
     const std::string& data_loss_message,
     const content::IndexedDBDatabaseMetadata& metadata) {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (!callbacks_)
     return;
 
   ::indexed_db::mojom::DatabaseAssociatedPtrInfo ptr_info;
   auto request = mojo::MakeRequest(&ptr_info);
-  mojo::MakeStrongAssociatedBinding(std::move(database), std::move(request));
+
+  dispatcher_host_->AddDatabaseBinding(std::move(database), std::move(request));
   callbacks_->UpgradeNeeded(std::move(ptr_info), old_version, data_loss,
                             data_loss_message, metadata);
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessDatabase(
     std::unique_ptr<DatabaseImpl> database,
     const content::IndexedDBDatabaseMetadata& metadata) {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (!callbacks_)
     return;
 
   ::indexed_db::mojom::DatabaseAssociatedPtrInfo ptr_info;
   if (database) {
     auto request = mojo::MakeRequest(&ptr_info);
-    mojo::MakeStrongAssociatedBinding(std::move(database), std::move(request));
+    dispatcher_host_->AddDatabaseBinding(std::move(database),
+                                         std::move(request));
   }
   callbacks_->SuccessDatabase(std::move(ptr_info), metadata);
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessCursor(
     std::unique_ptr<CursorImpl> cursor,
     const IndexedDBKey& key,
     const IndexedDBKey& primary_key,
     ::indexed_db::mojom::ValuePtr value,
     const std::vector<IndexedDBBlobInfo>& blob_info) {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (!callbacks_)
     return;
 
   if (value && !CreateAllBlobs(blob_info, &value->blob_or_file_info))
     return;
 
   ::indexed_db::mojom::CursorAssociatedPtrInfo ptr_info;
   auto request = mojo::MakeRequest(&ptr_info);
-  mojo::MakeStrongAssociatedBinding(std::move(cursor), std::move(request));
+  dispatcher_host_->AddCursorBinding(std::move(cursor), std::move(request));
   callbacks_->SuccessCursor(std::move(ptr_info), key, primary_key,
                             std::move(value));
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessValue(
     ::indexed_db::mojom::ReturnValuePtr value,
     const std::vector<IndexedDBBlobInfo>& blob_info) {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (!callbacks_)
     return;
 
   if (!value || CreateAllBlobs(blob_info, &value->value->blob_or_file_info))
     callbacks_->SuccessValue(std::move(value));
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessArray(
     std::vector<::indexed_db::mojom::ReturnValuePtr> mojo_values,
     const std::vector<IndexedDBReturnValue>& values) {
   DCHECK_EQ(mojo_values.size(), values.size());
 
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (!callbacks_)
     return;
 
   for (size_t i = 0; i < mojo_values.size(); ++i) {
     if (!CreateAllBlobs(values[i].blob_info,
                         &mojo_values[i]->value->blob_or_file_info))
       return;
   }
   callbacks_->SuccessArray(std::move(mojo_values));
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessCursorContinue(
     const IndexedDBKey& key,
     const IndexedDBKey& primary_key,
     ::indexed_db::mojom::ValuePtr value,
     const std::vector<IndexedDBBlobInfo>& blob_info) {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (!callbacks_)
     return;
 
   if (!value || CreateAllBlobs(blob_info, &value->blob_or_file_info))
     callbacks_->SuccessCursorContinue(key, primary_key, std::move(value));
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessCursorPrefetch(
     const std::vector<IndexedDBKey>& keys,
     const std::vector<IndexedDBKey>& primary_keys,
     std::vector<::indexed_db::mojom::ValuePtr> mojo_values,
     const std::vector<IndexedDBValue>& values) {
   DCHECK_EQ(mojo_values.size(), values.size());
 
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (!callbacks_)
     return;
 
   for (size_t i = 0; i < mojo_values.size(); ++i) {
     if (!CreateAllBlobs(values[i].blob_info,
                         &mojo_values[i]->blob_or_file_info)) {
       return;
     }
   }
 
   callbacks_->SuccessCursorPrefetch(keys, primary_keys, std::move(mojo_values));
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessKey(
     const IndexedDBKey& value) {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (callbacks_)
     callbacks_->SuccessKey(value);
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessInteger(int64_t value) {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (callbacks_)
     callbacks_->SuccessInteger(value);
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccess() {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return;
+  }
   if (callbacks_)
     callbacks_->Success();
 }
 
 std::string IndexedDBCallbacks::IOThreadHelper::CreateBlobData(
     const IndexedDBBlobInfo& blob_info) {
   if (!blob_info.uuid().empty()) {
     // We're sending back a live blob, not a reference into our backing store.
     return dispatcher_host_->HoldBlobData(blob_info);
   }
   scoped_refptr<ShareableFileReference> shareable_file =
       ShareableFileReference::Get(blob_info.file_path());
   if (!shareable_file) {
     shareable_file = ShareableFileReference::GetOrCreate(
         blob_info.file_path(),
         ShareableFileReference::DONT_DELETE_ON_FINAL_RELEASE,
         dispatcher_host_->context()->TaskRunner());
     if (!blob_info.release_callback().is_null())
       shareable_file->AddFinalReleaseCallback(blob_info.release_callback());
   }
   return dispatcher_host_->HoldBlobData(blob_info);
 }
 
 bool IndexedDBCallbacks::IOThreadHelper::CreateAllBlobs(
     const std::vector<IndexedDBBlobInfo>& blob_info,
     std::vector<::indexed_db::mojom::BlobInfoPtr>* blob_or_file_info) {
+  if (!dispatcher_host_) {
+    OnConnectionError();
+    return false;
+  }
   IDB_TRACE("IndexedDBCallbacks::CreateAllBlobs");
   DCHECK_EQ(blob_info.size(), blob_or_file_info->size());
   if (!dispatcher_host_->blob_storage_context())
     return false;
   for (size_t i = 0; i < blob_info.size(); ++i)
     (*blob_or_file_info)[i]->uuid = CreateBlobData(blob_info[i]);
   return true;
 }
 
 void IndexedDBCallbacks::IOThreadHelper::OnConnectionError() {
   callbacks_.reset();
   dispatcher_host_ = nullptr;
 }
 
 }  // namespace content