Replacing Indexed DB Chromium IPC with Mojo

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 "base/metrics/histogram.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "content/browser/child_process_security_policy_impl.h"
 #include "content/browser/fileapi/fileapi_message_filter.h"
 #include "content/browser/indexed_db/indexed_db_blob_info.h"
 #include "content/browser/indexed_db/indexed_db_connection.h"
 #include "content/browser/indexed_db/indexed_db_context_impl.h"
 #include "content/browser/indexed_db/indexed_db_cursor.h"
 #include "content/browser/indexed_db/indexed_db_database_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_database_error.h"
 #include "content/browser/indexed_db/indexed_db_metadata.h"
 #include "content/browser/indexed_db/indexed_db_return_value.h"
 #include "content/browser/indexed_db/indexed_db_tracing.h"
 #include "content/browser/indexed_db/indexed_db_value.h"
 #include "content/common/indexed_db/indexed_db_constants.h"
-#include "content/common/indexed_db/indexed_db_messages.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/shareable_file_reference.h"
 #include "storage/browser/quota/quota_manager.h"
 
 using storage::ShareableFileReference;
 
 namespace content {
 
+#if 0
 namespace {
 const int32_t kNoCursor = -1;
 const int32_t kNoDatabaseCallbacks = -1;
 const int64_t kNoTransaction = -1;
+
 }
 
 IndexedDBCallbacks::IndexedDBCallbacks(IndexedDBDispatcherHost* dispatcher_host,
                                        int32_t ipc_thread_id,
                                        int32_t ipc_callbacks_id)
     : dispatcher_host_(dispatcher_host),
       ipc_callbacks_id_(ipc_callbacks_id),
       ipc_thread_id_(ipc_thread_id),
       ipc_cursor_id_(kNoCursor),
       host_transaction_id_(kNoTransaction),
@@ skipping 25 matching lines @@
     : dispatcher_host_(dispatcher_host),
       ipc_callbacks_id_(ipc_callbacks_id),
       ipc_thread_id_(ipc_thread_id),
       ipc_cursor_id_(kNoCursor),
       host_transaction_id_(host_transaction_id),
       origin_(origin),
       ipc_database_id_(kNoDatabase),
       ipc_database_callbacks_id_(ipc_database_callbacks_id),
       data_loss_(blink::WebIDBDataLossNone),
       sent_blocked_(false) {}
+#endif
 
 IndexedDBCallbacks::~IndexedDBCallbacks() {}
 
 void IndexedDBCallbacks::OnError(const IndexedDBDatabaseError& error) {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   dispatcher_host_->Send(new IndexedDBMsg_CallbacksError(
       ipc_thread_id_, ipc_callbacks_id_, error.code(), error.message()));
   dispatcher_host_ = NULL;
 
   if (!connection_open_start_time_.is_null()) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "WebCore.IndexedDB.OpenTime.Error",
         base::TimeTicks::Now() - connection_open_start_time_);
     connection_open_start_time_ = base::TimeTicks();
   }
+#endif
 }
 
 void IndexedDBCallbacks::OnSuccess(const std::vector<base::string16>& value) {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(kNoDatabase, ipc_database_id_);
   DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
   std::vector<base::string16> list;
   for (unsigned i = 0; i < value.size(); ++i)
     list.push_back(value[i]);
 
   dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessStringList(
       ipc_thread_id_, ipc_callbacks_id_, list));
   dispatcher_host_ = NULL;
+#endif
 }
 
 void IndexedDBCallbacks::OnBlocked(int64_t existing_version) {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   // No transaction/db callbacks for DeleteDatabase.
   DCHECK_EQ(kNoTransaction == host_transaction_id_,
             kNoDatabaseCallbacks == ipc_database_callbacks_id_);
   DCHECK_EQ(kNoDatabase, ipc_database_id_);
 
   if (sent_blocked_)
     return;
 
   sent_blocked_ = true;
   dispatcher_host_->Send(new IndexedDBMsg_CallbacksIntBlocked(
       ipc_thread_id_, ipc_callbacks_id_, existing_version));
 
   if (!connection_open_start_time_.is_null()) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "WebCore.IndexedDB.OpenTime.Blocked",
         base::TimeTicks::Now() - connection_open_start_time_);
     connection_open_start_time_ = base::TimeTicks();
   }
+#endif
 }
 
 void IndexedDBCallbacks::OnDataLoss(blink::WebIDBDataLoss data_loss,
                                     std::string data_loss_message) {
+#if 0
   DCHECK_NE(blink::WebIDBDataLossNone, data_loss);
   data_loss_ = data_loss;
   data_loss_message_ = data_loss_message;
+#endif
 }
 
 void IndexedDBCallbacks::OnUpgradeNeeded(
     int64_t old_version,
     std::unique_ptr<IndexedDBConnection> connection,
     const IndexedDBDatabaseMetadata& metadata) {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_NE(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(kNoDatabase, ipc_database_id_);
   DCHECK_NE(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
 
   dispatcher_host_->RegisterTransactionId(host_transaction_id_, origin_);
   int32_t ipc_database_id =
       dispatcher_host_->Add(connection.release(), ipc_thread_id_, origin_);
@@ skipping 10 matching lines @@
   params.data_loss = data_loss_;
   params.data_loss_message = data_loss_message_;
   dispatcher_host_->Send(new IndexedDBMsg_CallbacksUpgradeNeeded(params));
 
   if (!connection_open_start_time_.is_null()) {
     UMA_HISTOGRAM_MEDIUM_TIMES(
         "WebCore.IndexedDB.OpenTime.UpgradeNeeded",
         base::TimeTicks::Now() - connection_open_start_time_);
     connection_open_start_time_ = base::TimeTicks();
   }
+#endif
 }
 
 void IndexedDBCallbacks::OnSuccess(
     std::unique_ptr<IndexedDBConnection> connection,
     const IndexedDBDatabaseMetadata& metadata) {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_NE(kNoTransaction, host_transaction_id_);
   DCHECK_NE(ipc_database_id_ == kNoDatabase, !connection);
   DCHECK_NE(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
 
   scoped_refptr<IndexedDBCallbacks> self(this);
 
   int32_t ipc_object_id = kNoDatabase;
@@ skipping 10 matching lines @@
       ipc_object_id,
       IndexedDBDispatcherHost::ConvertMetadata(metadata)));
   dispatcher_host_ = NULL;
 
   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();
   }
+#endif
 }
 
 static std::string CreateBlobData(
     const IndexedDBBlobInfo& blob_info,
-    scoped_refptr<IndexedDBDispatcherHost> dispatcher_host,
+    /*scoped_refptr<IndexedDBDispatcherHost> dispatcher_host,*/
     base::TaskRunner* task_runner) {
+#if 0
   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.get()) {
     shareable_file = ShareableFileReference::GetOrCreate(
         blob_info.file_path(),
         ShareableFileReference::DONT_DELETE_ON_FINAL_RELEASE,
         task_runner);
     if (!blob_info.release_callback().is_null())
       shareable_file->AddFinalReleaseCallback(blob_info.release_callback());
   }
   return dispatcher_host->HoldBlobData(blob_info);
+#else
+  return std::string();
+#endif
 }
 
+#if 0
 static bool CreateAllBlobs(
     const std::vector<IndexedDBBlobInfo>& blob_info,
     std::vector<IndexedDBMsg_BlobOrFileInfo>* blob_or_file_info,
     scoped_refptr<IndexedDBDispatcherHost> dispatcher_host) {
   IDB_TRACE("IndexedDBCallbacks::CreateAllBlobs");
   DCHECK_EQ(blob_info.size(), blob_or_file_info->size());
   size_t i;
   if (!dispatcher_host->blob_storage_context())
     return false;
   for (i = 0; i < blob_info.size(); ++i) {
@@ skipping 62 matching lines @@
       info.last_modified = iter.last_modified().ToDoubleT();
       blob_or_file_info->push_back(info);
     } else {
       IndexedDBMsg_BlobOrFileInfo info;
       info.mime_type = iter.type();
       info.size = iter.size();
       blob_or_file_info->push_back(info);
     }
   }
 }
+#endif
 
 void IndexedDBCallbacks::RegisterBlobsAndSend(
     const std::vector<IndexedDBBlobInfo>& blob_info,
     const base::Closure& callback) {
   for (const auto& iter : blob_info) {
     if (!iter.mark_used_callback().is_null())
       iter.mark_used_callback().Run();
   }
   DCHECK(!BrowserThread::CurrentlyOn(BrowserThread::IO));
   BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, callback);
 }
 
 void IndexedDBCallbacks::OnSuccess(scoped_refptr<IndexedDBCursor> cursor,
                                    const IndexedDBKey& key,
                                    const IndexedDBKey& primary_key,
                                    IndexedDBValue* value) {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(kNoDatabase, ipc_database_id_);
   DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
   int32_t ipc_object_id = dispatcher_host_->Add(cursor.get());
   std::unique_ptr<IndexedDBMsg_CallbacksSuccessIDBCursor_Params> params(
@@ skipping 14 matching lines @@
     FillInBlobData(value->blob_info, &p->value.blob_or_file_info);
     RegisterBlobsAndSend(
         value->blob_info,
         base::Bind(
             CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessIDBCursor_Params,
                                IndexedDBMsg_CallbacksSuccessIDBCursor>,
             base::Owned(params.release()), dispatcher_host_, value->blob_info,
             base::Unretained(&p->value.blob_or_file_info)));
   }
   dispatcher_host_ = NULL;
+#endif
 }
 
 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key,
                                    const IndexedDBKey& primary_key,
                                    IndexedDBValue* value) {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   DCHECK_NE(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(kNoDatabase, ipc_database_id_);
   DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
   IndexedDBCursor* idb_cursor =
       dispatcher_host_->GetCursorFromId(ipc_cursor_id_);
@@ skipping 22 matching lines @@
     RegisterBlobsAndSend(
         value->blob_info,
         base::Bind(CreateBlobsAndSend<
                        IndexedDBMsg_CallbacksSuccessCursorContinue_Params,
                        IndexedDBMsg_CallbacksSuccessCursorContinue>,
                    base::Owned(params.release()), dispatcher_host_,
                    value->blob_info,
                    base::Unretained(&p->value.blob_or_file_info)));
   }
   dispatcher_host_ = NULL;
+#endif
 }
 
 void IndexedDBCallbacks::OnSuccessWithPrefetch(
     const std::vector<IndexedDBKey>& keys,
     const std::vector<IndexedDBKey>& primary_keys,
     std::vector<IndexedDBValue>* values) {
+#if 0
   DCHECK_EQ(keys.size(), primary_keys.size());
   DCHECK_EQ(keys.size(), values->size());
 
   DCHECK(dispatcher_host_.get());
 
   DCHECK_NE(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(kNoDatabase, ipc_database_id_);
   DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
@@ skipping 34 matching lines @@
                             FROM_HERE,
                             base::Bind(BlobLookupForCursorPrefetch,
                                        base::Owned(params.release()),
                                        dispatcher_host_,
                                        *values));
   } else {
     dispatcher_host_->Send(
         new IndexedDBMsg_CallbacksSuccessCursorPrefetch(*params.get()));
   }
   dispatcher_host_ = NULL;
+#endif
 }
 
 void IndexedDBCallbacks::OnSuccess(IndexedDBReturnValue* value) {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   if (value && value->primary_key.IsValid()) {
     DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   } else {
     DCHECK(kNoCursor == ipc_cursor_id_ || value == NULL);
   }
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(kNoDatabase, ipc_database_id_);
   DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
@@ skipping 16 matching lines @@
     FillInBlobData(value->blob_info, &p->value.blob_or_file_info);
     RegisterBlobsAndSend(
         value->blob_info,
         base::Bind(CreateBlobsAndSend<IndexedDBMsg_CallbacksSuccessValue_Params,
                                       IndexedDBMsg_CallbacksSuccessValue>,
                    base::Owned(params.release()), dispatcher_host_,
                    value->blob_info,
                    base::Unretained(&p->value.blob_or_file_info)));
   }
   dispatcher_host_ = NULL;
+#endif
 }
 
 void IndexedDBCallbacks::OnSuccessArray(
     std::vector<IndexedDBReturnValue>* values,
     const IndexedDBKeyPath& key_path) {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(kNoDatabase, ipc_database_id_);
   DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
   std::unique_ptr<IndexedDBMsg_CallbacksSuccessArray_Params> params(
       new IndexedDBMsg_CallbacksSuccessArray_Params());
   params->ipc_thread_id = ipc_thread_id_;
@@ skipping 20 matching lines @@
   if (found_blob_info) {
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(BlobLookupForGetAll, base::Owned(params.release()),
                    dispatcher_host_, *values));
   } else {
     dispatcher_host_->Send(
         new IndexedDBMsg_CallbacksSuccessArray(*params.get()));
   }
   dispatcher_host_ = NULL;
+#endif
 }
 
 void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& value) {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(kNoDatabase, ipc_database_id_);
   DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
   dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessIndexedDBKey(
       ipc_thread_id_, ipc_callbacks_id_, value));
   dispatcher_host_ = NULL;
+#endif
 }
 
 void IndexedDBCallbacks::OnSuccess(int64_t value) {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(kNoDatabase, ipc_database_id_);
   DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
   dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessInteger(
       ipc_thread_id_, ipc_callbacks_id_, value));
   dispatcher_host_ = NULL;
+#endif
 }
 
 void IndexedDBCallbacks::OnSuccess() {
+#if 0
   DCHECK(dispatcher_host_.get());
 
   DCHECK_EQ(kNoCursor, ipc_cursor_id_);
   DCHECK_EQ(kNoTransaction, host_transaction_id_);
   DCHECK_EQ(kNoDatabase, ipc_database_id_);
   DCHECK_EQ(kNoDatabaseCallbacks, ipc_database_callbacks_id_);
   DCHECK_EQ(blink::WebIDBDataLossNone, data_loss_);
 
   dispatcher_host_->Send(new IndexedDBMsg_CallbacksSuccessUndefined(
       ipc_thread_id_, ipc_callbacks_id_));
   dispatcher_host_ = NULL;
+#endif
 }
 
 void IndexedDBCallbacks::SetConnectionOpenStartTime(
     const base::TimeTicks& start_time) {
   connection_open_start_time_ = start_time;
 }
 
 }  // namespace content