Send IndexedDB observations through IDBDatabaseCallbacks.

content/child/indexed_db/webidbfactory_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/webidbfactory_impl.h"
 
-#include "content/child/child_thread_impl.h"
 #include "content/child/indexed_db/indexed_db_callbacks_impl.h"
 #include "content/child/indexed_db/indexed_db_database_callbacks_impl.h"
 #include "content/child/storage_util.h"
-#include "content/public/child/worker_thread.h"
 #include "ipc/ipc_sync_channel.h"
 #include "mojo/public/cpp/bindings/strong_associated_binding.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 using blink::WebIDBCallbacks;
 using blink::WebIDBDatabase;
 using blink::WebIDBDatabaseCallbacks;
 using blink::WebSecurityOrigin;
 using blink::WebString;
 using indexed_db::mojom::CallbacksAssociatedPtrInfo;
 using indexed_db::mojom::DatabaseCallbacksAssociatedPtrInfo;
 using indexed_db::mojom::FactoryAssociatedPtr;
 
 namespace content {
 
 class WebIDBFactoryImpl::IOThreadHelper {
  public:
   IOThreadHelper(scoped_refptr<IPC::SyncMessageFilter> sync_message_filter);
   ~IOThreadHelper();
 
   FactoryAssociatedPtr& GetService();
   CallbacksAssociatedPtrInfo GetCallbacksProxy(
       std::unique_ptr<IndexedDBCallbacksImpl> callbacks);
   DatabaseCallbacksAssociatedPtrInfo GetDatabaseCallbacksProxy(
       std::unique_ptr<IndexedDBDatabaseCallbacksImpl> callbacks);
 
   void GetDatabaseNames(std::unique_ptr<IndexedDBCallbacksImpl> callbacks,
                         const url::Origin& origin);
-  void Open(int32_t worker_thread,
-            const base::string16& name,
+  void Open(const base::string16& name,
             int64_t version,
             int64_t transaction_id,
             std::unique_ptr<IndexedDBCallbacksImpl> callbacks,
             std::unique_ptr<IndexedDBDatabaseCallbacksImpl> database_callbacks,
             const url::Origin& origin);
   void DeleteDatabase(const base::string16& name,
                       std::unique_ptr<IndexedDBCallbacksImpl> callbacks,
                       const url::Origin& origin);
 
  private:
@@ skipping 31 matching lines @@
                              WebIDBDatabaseCallbacks* database_callbacks,
                              const WebSecurityOrigin& origin) {
   auto callbacks_impl = base::MakeUnique<IndexedDBCallbacksImpl>(
       base::WrapUnique(callbacks), transaction_id, nullptr, io_runner_);
   auto database_callbacks_impl =
       base::MakeUnique<IndexedDBDatabaseCallbacksImpl>(
           base::WrapUnique(database_callbacks));
   io_runner_->PostTask(
       FROM_HERE,
       base::Bind(&IOThreadHelper::Open, base::Unretained(io_helper_),
-                 WorkerThread::GetCurrentId(), base::string16(name), version,
-                 transaction_id, base::Passed(&callbacks_impl),
+                 base::string16(name), version, transaction_id,
+                 base::Passed(&callbacks_impl),
                  base::Passed(&database_callbacks_impl), url::Origin(origin)));
 }
 
 void WebIDBFactoryImpl::deleteDatabase(const WebString& name,
                                        WebIDBCallbacks* callbacks,
                                        const WebSecurityOrigin& origin) {
   auto callbacks_impl = base::MakeUnique<IndexedDBCallbacksImpl>(
       base::WrapUnique(callbacks), IndexedDBCallbacksImpl::kNoTransaction,
       nullptr, io_runner_);
   io_runner_->PostTask(
@@ skipping 37 matching lines @@
 }
 
 void WebIDBFactoryImpl::IOThreadHelper::GetDatabaseNames(
     std::unique_ptr<IndexedDBCallbacksImpl> callbacks,
     const url::Origin& origin) {
   GetService()->GetDatabaseNames(GetCallbacksProxy(std::move(callbacks)),
                                  origin);
 }
 
 void WebIDBFactoryImpl::IOThreadHelper::Open(
-    int32_t worker_thread,
     const base::string16& name,
     int64_t version,
     int64_t transaction_id,
     std::unique_ptr<IndexedDBCallbacksImpl> callbacks,
     std::unique_ptr<IndexedDBDatabaseCallbacksImpl> database_callbacks,
     const url::Origin& origin) {
-  GetService()->Open(worker_thread, GetCallbacksProxy(std::move(callbacks)),
+  GetService()->Open(GetCallbacksProxy(std::move(callbacks)),
                      GetDatabaseCallbacksProxy(std::move(database_callbacks)),
                      origin, name, version, transaction_id);
 }
 
 void WebIDBFactoryImpl::IOThreadHelper::DeleteDatabase(
     const base::string16& name,
     std::unique_ptr<IndexedDBCallbacksImpl> callbacks,
     const url::Origin& origin) {
   GetService()->DeleteDatabase(GetCallbacksProxy(std::move(callbacks)), origin,
                                name);
 }
 
 }  // namespace content