Remove indexed_db_messages.h.

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 114 matching lines @@
       std::vector<::indexed_db::mojom::ReturnValuePtr> mojo_values,
       const std::vector<IndexedDBReturnValue>& values);
   void SendSuccessKey(const IndexedDBKey& value);
   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();

[cmumford, 2017/01/05 00:29:01]

No longer need to include indexed_db_blob_info.h

[Reilly Grant (use Gerrit), 2017/01/06 02:23:35]

Done.

 
  private:
   scoped_refptr<IndexedDBDispatcherHost> dispatcher_host_;
   ::indexed_db::mojom::CallbacksAssociatedPtr callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(IOThreadHelper);
 };
 
 IndexedDBCallbacks::IndexedDBCallbacks(
     scoped_refptr<IndexedDBDispatcherHost> dispatcher_host,
@@ skipping 104 matching lines @@
   DCHECK(dispatcher_host_);
   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_)
+  if (!database_sent_) {
     database.reset(
         new DatabaseImpl(std::move(connection), origin_, dispatcher_host_));
+  }
 
   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",
@@ skipping 152 matching lines @@
   DCHECK(io_helper_);
 
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE,
                           base::Bind(&IOThreadHelper::SendSuccess,
                                      base::Unretained(io_helper_.get())));
   dispatcher_host_ = nullptr;
 }
 
-bool IndexedDBCallbacks::IsValid() const {
-  DCHECK(dispatcher_host_.get());
-
-  return dispatcher_host_->IsOpen();
-}
-
 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)) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  callbacks_.Bind(std::move(callbacks_info));
+  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) {
-  callbacks_->Error(error.code(), error.message());
+  if (callbacks_)
+    callbacks_->Error(error.code(), error.message());
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessStringList(
     const std::vector<base::string16>& value) {
-  callbacks_->SuccessStringList(value);
+  if (callbacks_)
+    callbacks_->SuccessStringList(value);
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendBlocked(int64_t existing_version) {
-  callbacks_->Blocked(existing_version);
+  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 (!callbacks_)
+    return;
+
   ::indexed_db::mojom::DatabaseAssociatedPtrInfo ptr_info;
   ::indexed_db::mojom::DatabaseAssociatedRequest request;
   callbacks_.associated_group()->CreateAssociatedInterface(
       mojo::AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
   mojo::MakeStrongAssociatedBinding(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) {
     ::indexed_db::mojom::DatabaseAssociatedRequest request;
     callbacks_.associated_group()->CreateAssociatedInterface(
         mojo::AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
     mojo::MakeStrongAssociatedBinding(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;
   ::indexed_db::mojom::CursorAssociatedRequest request;
   callbacks_.associated_group()->CreateAssociatedInterface(
       mojo::AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
   mojo::MakeStrongAssociatedBinding(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;
+
   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 (!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 (!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 (!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) {
-  callbacks_->SuccessKey(value);
+  if (callbacks_)
+    callbacks_->SuccessKey(value);
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccessInteger(int64_t value) {
-  callbacks_->SuccessInteger(value);
+  if (callbacks_)
+    callbacks_->SuccessInteger(value);
 }
 
 void IndexedDBCallbacks::IOThreadHelper::SendSuccess() {
-  callbacks_->Success();
+  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());
@@ skipping 13 matching lines @@
     std::vector<::indexed_db::mojom::BlobInfoPtr>* blob_or_file_info) {
   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