Send IndexedDB observations through IDBDatabaseCallbacks.

content/child/indexed_db/webidbdatabase_impl.cc

 // Copyright 2013 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/webidbdatabase_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
 
-#include "base/stl_util.h"
+#include "base/strings/string16.h"
+#include "base/strings/stringprintf.h"
 #include "content/child/indexed_db/indexed_db_callbacks_impl.h"
 #include "content/child/indexed_db/indexed_db_dispatcher.h"
 #include "content/child/indexed_db/indexed_db_key_builders.h"
-#include "content/child/worker_thread_registry.h"
-#include "content/common/indexed_db/indexed_db_messages.h"
 #include "mojo/public/cpp/bindings/strong_associated_binding.h"
 #include "third_party/WebKit/public/platform/WebBlobInfo.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseError.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBDatabaseException.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBKeyPath.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBMetadata.h"
 
 using blink::WebBlobInfo;
 using blink::WebIDBCallbacks;
-using blink::WebIDBCursor;
 using blink::WebIDBDatabase;
 using blink::WebIDBDatabaseCallbacks;
 using blink::WebIDBMetadata;
 using blink::WebIDBKey;
 using blink::WebIDBKeyPath;
 using blink::WebIDBKeyRange;
-using blink::WebIDBObserver;
 using blink::WebString;
 using blink::WebVector;
 using indexed_db::mojom::CallbacksAssociatedPtrInfo;
 using indexed_db::mojom::DatabaseAssociatedPtrInfo;
 
 namespace content {
 
 namespace {
 
 std::vector<content::IndexedDBIndexKeys> ConvertWebIndexKeys(
@@ skipping 161 matching lines @@
     blink::WebIDBTransactionMode mode) {
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::CreateTransaction, base::Unretained(helper_),
                  transaction_id, std::vector<int64_t>(object_store_ids.begin(),
                                                       object_store_ids.end()),
                  mode));
 }
 
 void WebIDBDatabaseImpl::close() {
-  std::vector<int32_t> remove_observer_ids(observer_ids_.begin(),
-                                           observer_ids_.end());
-  IndexedDBDispatcher::ThreadSpecificInstance()->RemoveObservers(
-      remove_observer_ids);
   io_runner_->PostTask(
       FROM_HERE, base::Bind(&IOThreadHelper::Close, base::Unretained(helper_)));
 }
 
 void WebIDBDatabaseImpl::versionChangeIgnored() {
   io_runner_->PostTask(FROM_HERE,
                        base::Bind(&IOThreadHelper::VersionChangeIgnored,
                                   base::Unretained(helper_)));
 }
 
-int32_t WebIDBDatabaseImpl::addObserver(
-    std::unique_ptr<WebIDBObserver> observer,
-    long long transaction_id) {
-  WebIDBObserver* observer_ptr = observer.get();
-  int32_t observer_id =
-      IndexedDBDispatcher::ThreadSpecificInstance()->RegisterObserver(
-          std::move(observer));
-  observer_ids_.insert(observer_id);
+void WebIDBDatabaseImpl::addObserver(
+    long long transaction_id,
+    int32_t observer_id,
+    bool include_transaction,
+    bool no_records,
+    bool values,
+    const std::bitset<blink::WebIDBOperationTypeCount>& operation_types) {
   static_assert(blink::WebIDBOperationTypeCount < sizeof(uint16_t) * CHAR_BIT,
                 "WebIDBOperationType Count exceeds size of uint16_t");
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::AddObserver, base::Unretained(helper_),
-                 transaction_id, observer_id, observer_ptr->transaction(),
-                 observer_ptr->noRecords(), observer_ptr->values(),
-                 observer_ptr->operationTypes().to_ulong()));
-  return observer_id;
+                 transaction_id, observer_id, include_transaction, no_records,
+                 values, operation_types.to_ulong()));
 }
 
 void WebIDBDatabaseImpl::removeObservers(
     const WebVector<int32_t>& observer_ids_to_remove) {
   std::vector<int32_t> remove_observer_ids(
       observer_ids_to_remove.data(),
       observer_ids_to_remove.data() + observer_ids_to_remove.size());
-  for (int32_t id : observer_ids_to_remove)
-    observer_ids_.erase(id);
 
-  IndexedDBDispatcher::ThreadSpecificInstance()->RemoveObservers(
-      remove_observer_ids);
   io_runner_->PostTask(
       FROM_HERE, base::Bind(&IOThreadHelper::RemoveObservers,
                             base::Unretained(helper_), remove_observer_ids));
 }
 
 void WebIDBDatabaseImpl::get(long long transaction_id,
                              long long object_store_id,
                              long long index_id,
                              const WebIDBKeyRange& key_range,
                              bool key_only,
@@ skipping 26 matching lines @@
       FROM_HERE,
       base::Bind(&IOThreadHelper::GetAll, base::Unretained(helper_),
                  transaction_id, object_store_id, index_id,
                  IndexedDBKeyRangeBuilder::Build(key_range), max_count,
                  key_only, base::Passed(&callbacks_impl)));
 }
 
 void WebIDBDatabaseImpl::put(long long transaction_id,
                              long long object_store_id,
                              const blink::WebData& value,
-                             const blink::WebVector<WebBlobInfo>& web_blob_info,
+                             const WebVector<WebBlobInfo>& web_blob_info,
                              const WebIDBKey& web_key,
                              blink::WebIDBPutMode put_mode,
                              WebIDBCallbacks* callbacks,
                              const WebVector<long long>& index_ids,
                              const WebVector<WebIndexKeys>& index_keys) {
   IndexedDBKey key = IndexedDBKeyBuilder::Build(web_key);
 
   if (value.size() + key.size_estimate() > max_put_value_size_) {
     callbacks->onError(blink::WebIDBDatabaseError(
         blink::WebIDBDatabaseExceptionUnknownError,
@@ skipping 387 matching lines @@
     std::unique_ptr<IndexedDBCallbacksImpl> callbacks) {
   CallbacksAssociatedPtrInfo ptr_info;
   indexed_db::mojom::CallbacksAssociatedRequest request;
   database_.associated_group()->CreateAssociatedInterface(
       mojo::AssociatedGroup::WILL_PASS_PTR, &ptr_info, &request);
   mojo::MakeStrongAssociatedBinding(std::move(callbacks), std::move(request));
   return ptr_info;
 }
 
 }  // namespace content