[IndexedDB] Refactoring to remove ref ptrs and host transaction ids.

content/browser/indexed_db/indexed_db_dispatcher_host.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_dispatcher_host.h"
 
 #include <stddef.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/memory/ptr_util.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/browser/bad_message.h"
 #include "content/browser/indexed_db/indexed_db_callbacks.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_database_callbacks.h"
 #include "content/browser/indexed_db/indexed_db_pending_connection.h"
+#include "content/browser/indexed_db/indexed_db_transaction.h"
 #include "content/browser/indexed_db/indexed_db_value.h"
 #include "content/browser/renderer_host/render_message_filter.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "content/common/indexed_db/indexed_db_metadata.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_storage_context.h"
@@ skipping 63 matching lines @@
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   // Prevent any pending connections from being processed.
   is_open_ = false;
 }
 
 bool IndexedDBDispatcherHost::OnMessageReceived(const IPC::Message& message) {
   return false;
 }
 
-bool IndexedDBDispatcherHost::RegisterTransactionId(int64_t host_transaction_id,
-                                                    const url::Origin& origin) {
-  if (base::ContainsKey(transaction_size_map_, host_transaction_id))
-    return false;
-  transaction_size_map_[host_transaction_id] = 0;
-  transaction_origin_map_[host_transaction_id] = origin;
-  return true;
-}
-
-bool IndexedDBDispatcherHost::GetTransactionSize(int64_t host_transaction_id,
-                                                 int64_t* transaction_size) {
-  const auto it = transaction_size_map_.find(host_transaction_id);
-  if (it == transaction_size_map_.end())
-    return false;
-  *transaction_size = it->second;
-  return true;
-}
-
-void IndexedDBDispatcherHost::AddToTransaction(int64_t host_transaction_id,
-                                               int64_t value_length) {
-  transaction_size_map_[host_transaction_id] += value_length;
-}
-
-int64_t IndexedDBDispatcherHost::HostTransactionId(int64_t transaction_id) {
-  // Inject the renderer process id into the transaction id, to
-  // uniquely identify this transaction, and effectively bind it to
-  // the renderer that initiated it. The lower 32 bits of
-  // transaction_id are guaranteed to be unique within that renderer.
-  base::ProcessId pid = peer_pid();
-  DCHECK(!(transaction_id >> 32)) << "Transaction ids can only be 32 bits";
-  static_assert(sizeof(base::ProcessId) <= sizeof(int32_t),
-                "Process ID must fit in 32 bits");
-
-  return transaction_id | (static_cast<uint64_t>(pid) << 32);
-}
-
-int64_t IndexedDBDispatcherHost::RendererTransactionId(
-    int64_t host_transaction_id) {
-  DCHECK(host_transaction_id >> 32 == peer_pid())
-      << "Invalid renderer target for transaction id";
-  return host_transaction_id & 0xffffffff;
-}
-
-// static
-uint32_t IndexedDBDispatcherHost::TransactionIdToRendererTransactionId(
-    int64_t host_transaction_id) {
-  return host_transaction_id & 0xffffffff;
-}
-
-// static
-uint32_t IndexedDBDispatcherHost::TransactionIdToProcessId(
-    int64_t host_transaction_id) {
-  return (host_transaction_id >> 32) & 0xffffffff;
-}
-
 std::string IndexedDBDispatcherHost::HoldBlobData(
     const IndexedDBBlobInfo& blob_info) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   std::string uuid = blob_info.uuid();
   storage::BlobStorageContext* context = blob_storage_context_->context();
   std::unique_ptr<storage::BlobDataHandle> blob_data_handle;
   if (uuid.empty()) {
     uuid = base::GenerateGUID();
     storage::BlobDataBuilder blob_data_builder(uuid);
     blob_data_builder.set_content_type(base::UTF16ToUTF8(blob_info.type()));
@@ skipping 111 matching lines @@
     scoped_refptr<IndexedDBDatabaseCallbacks> database_callbacks,
     const url::Origin& origin,
     const base::string16& name,
     int64_t version,
     int64_t transaction_id) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   base::TimeTicks begin_time = base::TimeTicks::Now();
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
 
-  int64_t host_transaction_id = HostTransactionId(transaction_id);
-
   // TODO(dgrogan): Don't let a non-existing database be opened (and therefore
   // created) if this origin is already over quota.
   callbacks->SetConnectionOpenStartTime(begin_time);
-  callbacks->set_host_transaction_id(host_transaction_id);
+  callbacks->set_host_transaction_id(transaction_id);

[Reilly Grant (use Gerrit), 2016/11/30 16:32:26]

This isn't necessary anymore now that OnUpgradeNeeded gets a reference to the
transaction.

[dmurph, 2016/11/30 23:13:07]

Done.

   std::unique_ptr<IndexedDBPendingConnection> connection =
       base::MakeUnique<IndexedDBPendingConnection>(
-          callbacks, database_callbacks, ipc_process_id_, host_transaction_id,
+          callbacks, database_callbacks, ipc_process_id_, transaction_id,
           version);
   DCHECK(request_context_getter_);
   context()->GetIDBFactory()->Open(name, std::move(connection),
                                    request_context_getter_, origin,
                                    indexed_db_path);
 }
 
 void IndexedDBDispatcherHost::DeleteDatabaseOnIDBThread(
     scoped_refptr<IndexedDBCallbacks> callbacks,
     const url::Origin& origin,
     const base::string16& name) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
 
   base::FilePath indexed_db_path = indexed_db_context_->data_path();
   DCHECK(request_context_getter_);
   context()->GetIDBFactory()->DeleteDatabase(
       name, request_context_getter_, callbacks, origin, indexed_db_path);
 }
 
-void IndexedDBDispatcherHost::FinishTransaction(int64_t host_transaction_id,
-                                                bool committed) {
+void IndexedDBDispatcherHost::NotifyTransactionCommitted(
+    const url::Origin& transaction_origin) {
   DCHECK(indexed_db_context_->TaskRunner()->RunsTasksOnCurrentThread());
-  if (committed) {
-    context()->TransactionComplete(
-        transaction_origin_map_[host_transaction_id]);
-  }
-  transaction_origin_map_.erase(host_transaction_id);
-  transaction_size_map_.erase(host_transaction_id);
+  context()->TransactionComplete(transaction_origin);
 }
 
 }  // namespace content