IndexedDB: Move helpers out of IndexedDBCallbacks so they're accessible

This CL:
- Moves ConvertReturnValue to IndexedDBReturnValue
- Moves ConvertBlobInfo to IndexedDBBlobInfo
- Moves ConvertAndEraseValue to IndexedDBValue

These are needed by a later change to move code out of
IndexedDBCallbacks and use Mojo's native async return calls, instead.

Bug: 717812
Change-Id: I9f02a26eb024a3e790eddc16185d426cf530108e
Reviewed-on: https://chromium-review.googlesource.com/c/1336660
Commit-Queue: Chase Phillips <cmp@chromium.org>
Reviewed-by: Victor Costan <pwnall@chromium.org>
Cr-Commit-Position: refs/heads/master@{#609420}

content/browser/BUILD.gn

@@ -991,6 +991,7 @@ jumbo_source_set("browser") {
     "indexed_db/indexed_db_quota_client.h",
     "indexed_db/indexed_db_reporting.cc",
     "indexed_db/indexed_db_reporting.h",
+    "indexed_db/indexed_db_return_value.cc",
     "indexed_db/indexed_db_return_value.h",
     "indexed_db/indexed_db_tombstone_sweeper.cc",
     "indexed_db/indexed_db_tombstone_sweeper.h",

content/browser/indexed_db/indexed_db_blob_info.cc

@@ -7,9 +7,32 @@
 #include "base/bind.h"
 #include "base/logging.h"
 #include "content/browser/indexed_db/indexed_db_leveldb_coding.h"
+#include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom.h"
 
 namespace content {
 
+// static
+void IndexedDBBlobInfo::ConvertBlobInfo(
+    const std::vector<IndexedDBBlobInfo>& blob_info,
+    std::vector<blink::mojom::IDBBlobInfoPtr>* blob_or_file_info) {
+  blob_or_file_info->reserve(blob_info.size());
+  for (const auto& iter : blob_info) {
+    if (!iter.mark_used_callback().is_null())
+      iter.mark_used_callback().Run();
+
+    auto info = blink::mojom::IDBBlobInfo::New();
+    info->mime_type = iter.type();
+    info->size = iter.size();
+    if (iter.is_file()) {
+      info->file = blink::mojom::IDBFileInfo::New();
+      info->file->name = iter.file_name();
+      info->file->path = iter.file_path();
+      info->file->last_modified = iter.last_modified();
+    }
+    blob_or_file_info->push_back(std::move(info));
+  }
+}
+
 IndexedDBBlobInfo::IndexedDBBlobInfo()
     : is_file_(false), size_(-1), key_(DatabaseMetaDataKey::kInvalidBlobKey) {
 }

content/browser/indexed_db/indexed_db_blob_info.h

@@ -15,6 +15,7 @@
 #include "base/time/time.h"
 #include "content/common/content_export.h"
 #include "storage/browser/blob/blob_data_handle.h"
+#include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom.h"
 
 namespace content {
 
@@ -22,6 +23,11 @@ class CONTENT_EXPORT IndexedDBBlobInfo {
  public:
   // TODO(mek): Use ShareableFileReference::FinalReleaseCallback somehow.
   typedef base::RepeatingCallback<void(const base::FilePath&)> ReleaseCallback;
+
+  static void ConvertBlobInfo(
+      const std::vector<IndexedDBBlobInfo>& blob_info,
+      std::vector<blink::mojom::IDBBlobInfoPtr>* blob_or_file_info);
+
   IndexedDBBlobInfo();
   // These two are used for Blobs.
   IndexedDBBlobInfo(std::unique_ptr<storage::BlobDataHandle> blob_handle,

content/browser/indexed_db/indexed_db_callbacks.cc

@@ -92,49 +92,6 @@ class SafeIOThreadCursorWrapper {
   DISALLOW_COPY_AND_ASSIGN(SafeIOThreadCursorWrapper);
 };
 
-void ConvertBlobInfo(
-    const std::vector<IndexedDBBlobInfo>& blob_info,
-    std::vector<blink::mojom::IDBBlobInfoPtr>* blob_or_file_info) {
-  blob_or_file_info->reserve(blob_info.size());
-  for (const auto& iter : blob_info) {
-    if (!iter.mark_used_callback().is_null())
-      iter.mark_used_callback().Run();
-
-    auto info = blink::mojom::IDBBlobInfo::New();
-    info->mime_type = iter.type();
-    info->size = iter.size();
-    if (iter.is_file()) {
-      info->file = blink::mojom::IDBFileInfo::New();
-      info->file->name = iter.file_name();
-      info->file->path = iter.file_path();
-      info->file->last_modified = iter.last_modified();
-    }
-    blob_or_file_info->push_back(std::move(info));
-  }
-}
-
-// Destructively converts an IndexedDBReturnValue to a Mojo ReturnValue.
-blink::mojom::IDBReturnValuePtr ConvertReturnValue(
-    IndexedDBReturnValue* value) {
-  auto mojo_value = blink::mojom::IDBReturnValue::New();
-  mojo_value->value = blink::mojom::IDBValue::New();
-  if (value->primary_key.IsValid()) {
-    mojo_value->primary_key = value->primary_key;
-    mojo_value->key_path = value->key_path;
-  }
-  if (!value->empty()) {
-    // TODO(crbug.com/902498): Use mojom traits to map directly from
-    //                         std::string.
-    const char* value_data = value->bits.data();
-    mojo_value->value->bits =
-        std::vector<uint8_t>(value_data, value_data + value->bits.length());
-    // Release value->bits std::string.
-    value->bits.clear();
-  }
-  ConvertBlobInfo(value->blob_info, &mojo_value->value->blob_or_file_info);
-  return mojo_value;
-}
-
 }  // namespace
 
 // Expected to be created and called from IO thread.
@@ -198,23 +155,6 @@ class IndexedDBCallbacks::IOThreadHelper {
   DISALLOW_COPY_AND_ASSIGN(IOThreadHelper);
 };
 
-// static
-blink::mojom::IDBValuePtr IndexedDBCallbacks::ConvertAndEraseValue(
-    IndexedDBValue* value) {
-  auto mojo_value = blink::mojom::IDBValue::New();
-  if (!value->empty()) {
-    // TODO(crbug.com/902498): Use mojom traits to map directly from
-    //                         std::string.
-    const char* value_data = value->bits.data();
-    mojo_value->bits =
-        std::vector<uint8_t>(value_data, value_data + value->bits.length());
-    // Release value->bits std::string.
-    value->bits.clear();
-  }
-  ConvertBlobInfo(value->blob_info, &mojo_value->blob_or_file_info);
-  return mojo_value;
-}
-
 IndexedDBCallbacks::IndexedDBCallbacks(
     base::WeakPtr<IndexedDBDispatcherHost> dispatcher_host,
     const url::Origin& origin,
@@ -347,7 +287,7 @@ void IndexedDBCallbacks::OnSuccess(std::unique_ptr<IndexedDBCursor> cursor,
   blink::mojom::IDBValuePtr mojo_value;
   std::vector<IndexedDBBlobInfo> blob_info;
   if (value) {
-    mojo_value = ConvertAndEraseValue(value);
+    mojo_value = IndexedDBValue::ConvertAndEraseValue(value);
     blob_info.swap(value->blob_info);
   }
 
@@ -374,7 +314,7 @@ void IndexedDBCallbacks::OnSuccess(const IndexedDBKey& key,
   blink::mojom::IDBValuePtr mojo_value;
   std::vector<IndexedDBBlobInfo> blob_info;
   if (value) {
-    mojo_value = ConvertAndEraseValue(value);
+    mojo_value = IndexedDBValue::ConvertAndEraseValue(value);
     blob_info.swap(value->blob_info);
   }
 
@@ -401,7 +341,7 @@ void IndexedDBCallbacks::OnSuccessWithPrefetch(
   std::vector<blink::mojom::IDBValuePtr> mojo_values;
   mojo_values.reserve(values->size());
   for (size_t i = 0; i < values->size(); ++i)
-    mojo_values.push_back(ConvertAndEraseValue(&(*values)[i]));
+    mojo_values.push_back(IndexedDBValue::ConvertAndEraseValue(&(*values)[i]));
 
   base::PostTaskWithTraits(
       FROM_HERE, {BrowserThread::IO},
@@ -420,7 +360,7 @@ void IndexedDBCallbacks::OnSuccess(IndexedDBReturnValue* value) {
   blink::mojom::IDBReturnValuePtr mojo_value;
   std::vector<IndexedDBBlobInfo> blob_info;
   if (value) {
-    mojo_value = ConvertReturnValue(value);
+    mojo_value = IndexedDBReturnValue::ConvertReturnValue(value);
     blob_info = value->blob_info;
   }
 
@@ -442,8 +382,10 @@ void IndexedDBCallbacks::OnSuccessArray(
 
   std::vector<blink::mojom::IDBReturnValuePtr> mojo_values;
   mojo_values.reserve(values->size());
-  for (size_t i = 0; i < values->size(); ++i)
-    mojo_values.push_back(ConvertReturnValue(&(*values)[i]));
+  for (size_t i = 0; i < values->size(); ++i) {
+    mojo_values.push_back(
+        IndexedDBReturnValue::ConvertReturnValue(&(*values)[i]));
+  }
 
   base::PostTaskWithTraits(FROM_HERE, {BrowserThread::IO},
                            base::BindOnce(&IOThreadHelper::SendSuccessArray,

content/browser/indexed_db/indexed_db_callbacks.h

@@ -43,9 +43,6 @@ struct IndexedDBValue;
 class CONTENT_EXPORT IndexedDBCallbacks
     : public base::RefCounted<IndexedDBCallbacks> {
  public:
-  // Destructively converts an IndexedDBValue to a Mojo Value.
-  static blink::mojom::IDBValuePtr ConvertAndEraseValue(IndexedDBValue* value);
-
   IndexedDBCallbacks(base::WeakPtr<IndexedDBDispatcherHost> dispatcher_host,
                      const url::Origin& origin,
                      blink::mojom::IDBCallbacksAssociatedPtrInfo callbacks_info,

content/browser/indexed_db/indexed_db_database.cc

@@ -870,7 +870,7 @@ void IndexedDBDatabase::FilterObservation(IndexedDBTransaction* transaction,
         // indexeddb value. crbug.com/682363
         IndexedDBValue copy = *value;
         changes->observations.back()->value =
-            IndexedDBCallbacks::ConvertAndEraseValue(&copy);
+            IndexedDBValue::ConvertAndEraseValue(&copy);
       }
     }
   }

content/browser/indexed_db/indexed_db_return_value.cc

+// Copyright 2015 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_return_value.h"
+
+#include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom.h"
+
+namespace content {
+
+// static
+blink::mojom::IDBReturnValuePtr IndexedDBReturnValue::ConvertReturnValue(
+    IndexedDBReturnValue* value) {
+  auto mojo_value = blink::mojom::IDBReturnValue::New();
+  mojo_value->value = blink::mojom::IDBValue::New();
+  if (value->primary_key.IsValid()) {
+    mojo_value->primary_key = value->primary_key;
+    mojo_value->key_path = value->key_path;
+  }
+  if (!value->empty()) {
+    // TODO(crbug.com/902498): Use mojom traits to map directly from
+    //                         std::string.
+    const char* value_data = value->bits.data();
+    mojo_value->value->bits =
+        std::vector<uint8_t>(value_data, value_data + value->bits.length());
+    // Release value->bits std::string.
+    value->bits.clear();
+  }
+  IndexedDBBlobInfo::ConvertBlobInfo(value->blob_info,
+                                     &mojo_value->value->blob_or_file_info);
+  return mojo_value;
+}
+
+}  // namespace content

content/browser/indexed_db/indexed_db_return_value.h

@@ -18,6 +18,10 @@ namespace content {
 // database, so they are kept separately, and sent back with the original data
 // so that the render process can amend the returned object.
 struct CONTENT_EXPORT IndexedDBReturnValue : public IndexedDBValue {
+  // Destructively converts an IndexedDBReturnValue to a Mojo ReturnValue.
+  static blink::mojom::IDBReturnValuePtr ConvertReturnValue(
+      IndexedDBReturnValue* value);
+
   blink::IndexedDBKey
       primary_key;  // primary key (only when using key generator)
   blink::IndexedDBKeyPath key_path;

content/browser/indexed_db/indexed_db_value.cc

@@ -5,9 +5,28 @@
 #include "content/browser/indexed_db/indexed_db_value.h"
 
 #include "base/logging.h"
+#include "third_party/blink/public/mojom/indexeddb/indexeddb.mojom.h"
 
 namespace content {
 
+// static
+blink::mojom::IDBValuePtr IndexedDBValue::ConvertAndEraseValue(
+    IndexedDBValue* value) {
+  auto mojo_value = blink::mojom::IDBValue::New();
+  if (!value->empty()) {
+    // TODO(crbug.com/902498): Use mojom traits to map directly from
+    //                         std::string.
+    const char* value_data = value->bits.data();
+    mojo_value->bits =
+        std::vector<uint8_t>(value_data, value_data + value->bits.length());
+    // Release value->bits std::string.
+    value->bits.clear();
+  }
+  IndexedDBBlobInfo::ConvertBlobInfo(value->blob_info,
+                                     &mojo_value->blob_or_file_info);
+  return mojo_value;
+}
+
 IndexedDBValue::IndexedDBValue() = default;
 IndexedDBValue::IndexedDBValue(
     const std::string& input_bits,

content/browser/indexed_db/indexed_db_value.h

@@ -17,6 +17,9 @@
 namespace content {
 
 struct CONTENT_EXPORT IndexedDBValue {
+  // Destructively converts an IndexedDBValue to a Mojo Value.
+  static blink::mojom::IDBValuePtr ConvertAndEraseValue(IndexedDBValue* value);
+
   IndexedDBValue();
   IndexedDBValue(const std::string& input_bits,
                  const std::vector<IndexedDBBlobInfo>& input_blob_info);