[IndexedDB] Adding transaction and value support to observers

content/child/indexed_db/indexed_db_callbacks_impl.cc

 // Copyright 2016 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/child/indexed_db/indexed_db_callbacks_impl.h"
 
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/child/indexed_db/indexed_db_dispatcher.h"
 #include "content/child/indexed_db/indexed_db_key_builders.h"
 #include "content/child/indexed_db/webidbcursor_impl.h"
@@ skipping 47 matching lines @@
   output->name = WebString::fromUTF16(metadata.name);
   output->version = metadata.version;
   output->maxObjectStoreId = metadata.max_object_store_id;
   output->objectStores =
       WebVector<WebIDBMetadata::ObjectStore>(metadata.object_stores.size());
   size_t i = 0;
   for (const auto& iter : metadata.object_stores)
     ConvertObjectStoreMetadata(iter.second, &output->objectStores[i++]);
 }
 
-void ConvertValue(const indexed_db::mojom::ValuePtr& value,
-                  WebIDBValue* web_value) {
+void ConvertReturnValue(const indexed_db::mojom::ReturnValuePtr& value,
+                        WebIDBValue* web_value) {
+  IndexedDBCallbacksImpl::ConvertValue(value->value, web_value);
+  web_value->primaryKey = WebIDBKeyBuilder::Build(value->primary_key);
+  web_value->keyPath = WebIDBKeyPathBuilder::Build(value->key_path);
+}
+
+}  // namespace
+
+/* static */ void IndexedDBCallbacksImpl::ConvertValue(
+    const indexed_db::mojom::ValuePtr& value,
+    WebIDBValue* web_value) {
   if (value->bits.empty())
     return;
 
   blink::WebVector<WebBlobInfo> local_blob_info(
       value->blob_or_file_info.size());
   for (size_t i = 0; i < value->blob_or_file_info.size(); ++i) {
     const auto& info = value->blob_or_file_info[i];
     if (info->file) {
       local_blob_info[i] =
           WebBlobInfo(WebString::fromUTF8(info->uuid),
                       blink::FilePathToWebString(info->file->path),
                       WebString::fromUTF16(info->file->name),
                       WebString::fromUTF16(info->mime_type),
                       info->file->last_modified.ToDoubleT(), info->size);
     } else {
       local_blob_info[i] =
           WebBlobInfo(WebString::fromUTF8(info->uuid),
                       WebString::fromUTF16(info->mime_type), info->size);
     }
   }
 
   web_value->data.assign(&*value->bits.begin(), value->bits.size());
   web_value->webBlobInfo.swap(local_blob_info);
 }
 
-void ConvertReturnValue(const indexed_db::mojom::ReturnValuePtr& value,
-                        WebIDBValue* web_value) {
-  ConvertValue(value->value, web_value);
-  web_value->primaryKey = WebIDBKeyBuilder::Build(value->primary_key);
-  web_value->keyPath = WebIDBKeyPathBuilder::Build(value->key_path);
-}
-
-}  // namespace
 
 IndexedDBCallbacksImpl::IndexedDBCallbacksImpl(
     std::unique_ptr<WebIDBCallbacks> callbacks,
     int64_t transaction_id,
     const base::WeakPtr<WebIDBCursorImpl>& cursor,
     scoped_refptr<base::SingleThreadTaskRunner> io_runner)
     : internal_state_(new InternalState(std::move(callbacks),
                                         transaction_id,
                                         cursor,
                                         std::move(io_runner))),
@@ skipping 181 matching lines @@
   callbacks_.reset();
 }
 
 void IndexedDBCallbacksImpl::InternalState::SuccessCursor(
     indexed_db::mojom::CursorAssociatedPtrInfo cursor_info,
     const IndexedDBKey& key,
     const IndexedDBKey& primary_key,
     indexed_db::mojom::ValuePtr value) {
   WebIDBValue web_value;
   if (value)
-    ConvertValue(value, &web_value);
+    IndexedDBCallbacksImpl::ConvertValue(value, &web_value);
 
   WebIDBCursorImpl* cursor =
       new WebIDBCursorImpl(std::move(cursor_info), transaction_id_, io_runner_);
   callbacks_->onSuccess(cursor, WebIDBKeyBuilder::Build(key),
                         WebIDBKeyBuilder::Build(primary_key), web_value);
   callbacks_.reset();
 }
 
 void IndexedDBCallbacksImpl::InternalState::SuccessKey(
     const IndexedDBKey& key) {
@@ skipping 50 matching lines @@
   callbacks_->onSuccess(value);
   callbacks_.reset();
 }
 
 void IndexedDBCallbacksImpl::InternalState::Success() {
   callbacks_->onSuccess();
   callbacks_.reset();
 }
 
 }  // namespace content