[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 208 matching lines @@
     const IndexedDBDataLossInfo& data_loss_info) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(dispatcher_host_);
   DCHECK(io_helper_);
 
   DCHECK(!database_sent_);
 
   data_loss_ = data_loss_info.status;
   database_sent_ = true;
   auto database = base::MakeUnique<DatabaseImpl>(std::move(connection), origin_,
-                                                 dispatcher_host_);
+                                                 dispatcher_host_.get());
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&IOThreadHelper::SendUpgradeNeeded,
                  base::Unretained(io_helper_.get()), base::Passed(&database),
                  old_version, data_loss_info.status, data_loss_info.message,
                  metadata));
 
   if (!connection_open_start_time_.is_null()) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
@@ skipping 11 matching lines @@
   DCHECK(io_helper_);
 
   DCHECK_EQ(database_sent_, !connection);
 
   scoped_refptr<IndexedDBCallbacks> self(this);
 
   // Only send a new Database if the connection was not previously sent in
   // OnUpgradeNeeded.
   std::unique_ptr<DatabaseImpl> database;
   if (!database_sent_) {
-    database.reset(
-        new DatabaseImpl(std::move(connection), origin_, dispatcher_host_));
+    database.reset(new DatabaseImpl(std::move(connection), origin_,
+                                    dispatcher_host_.get()));
   }
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&IOThreadHelper::SendSuccessDatabase,
                                      base::Unretained(io_helper_.get()),
                                      base::Passed(&database), metadata));
   dispatcher_host_ = nullptr;
 
   if (!connection_open_start_time_.is_null()) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "WebCore.IndexedDB.OpenTime.Success",
         base::TimeTicks::Now() - connection_open_start_time_);
     connection_open_start_time_ = base::TimeTicks();
   }
 }
 
 void IndexedDBCallbacks::OnSuccess(std::unique_ptr<IndexedDBCursor> cursor,
                                    const IndexedDBKey& key,
                                    const IndexedDBKey& primary_key,
                                    IndexedDBValue* value) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(dispatcher_host_);
   DCHECK(io_helper_);
 
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
   auto cursor_impl = base::MakeUnique<CursorImpl>(std::move(cursor), origin_,
-                                                  dispatcher_host_);
+                                                  dispatcher_host_.get());
 
   ::indexed_db::mojom::ValuePtr mojo_value;
   std::vector<IndexedDBBlobInfo> blob_info;
   if (value) {
     mojo_value = ConvertAndEraseValue(value);
     blob_info.swap(value->blob_info);
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
@@ skipping 172 matching lines @@
     std::unique_ptr<DatabaseImpl> database,
     int64_t old_version,
     blink::WebIDBDataLoss data_loss,
     const std::string& data_loss_message,
     const content::IndexedDBDatabaseMetadata& metadata) {
   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 (!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 (!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 (!callbacks_)
     return;
 
@@ skipping 95 matching lines @@
     (*blob_or_file_info)[i]->uuid = CreateBlobData(blob_info[i]);
   return true;
 }
 
 void IndexedDBCallbacks::IOThreadHelper::OnConnectionError() {
   callbacks_.reset();
   dispatcher_host_ = nullptr;
 }
 
 }  // namespace content