IDBObserver: Lifetime Management: Adding Observer

content/child/indexed_db/indexed_db_dispatcher.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/indexed_db_dispatcher.h"
 
 #include <utility>
 
 #include "base/format_macros.h"
 #include "base/lazy_instance.h"
@@ skipping 12 matching lines @@
 
 using blink::WebBlobInfo;
 using blink::WebData;
 using blink::WebIDBCallbacks;
 using blink::WebIDBCursor;
 using blink::WebIDBDatabase;
 using blink::WebIDBDatabaseCallbacks;
 using blink::WebIDBDatabaseError;
 using blink::WebIDBKey;
 using blink::WebIDBMetadata;
+using blink::WebIDBObserver;
 using blink::WebIDBValue;
 using blink::WebString;
 using blink::WebVector;
 using base::ThreadLocalPointer;
 
 namespace content {
 static base::LazyInstance<ThreadLocalPointer<IndexedDBDispatcher> >::Leaky
     g_idb_dispatcher_tls = LAZY_INSTANCE_INITIALIZER;
 
 namespace {
@@ skipping 117 matching lines @@
   // If a message gets here, IndexedDBMessageFilter already determined that it
   // is an IndexedDB message.
   DCHECK(handled) << "Didn't handle a message defined at line "
                   << IPC_MESSAGE_ID_LINE(msg.type());
 }
 
 bool IndexedDBDispatcher::Send(IPC::Message* msg) {
   return thread_safe_sender_->Send(msg);
 }
 
+int32_t IndexedDBDispatcher::AddIDBObserver(
+    int32_t ipc_database_id,
+    int64_t transaction_id,
+    std::unique_ptr<WebIDBObserver> observer) {
+  int32_t observer_id = observers_.Add(observer.release());
+  Send(new IndexedDBHostMsg_DatabaseObserve(ipc_database_id, transaction_id,
+                                            observer_id));
+  return observer_id;
+}
+
+std::vector<int32_t> IndexedDBDispatcher::RemoveIDBObserversFromDatabase(
+    int32_t ipc_database_id,
+    std::unique_ptr<WebIDBObserver> observer,
+    const std::vector<int32_t>& database_observer_ids) {
+  std::vector<int32_t> observer_ids_to_remove;
+  for (uint32_t i = 0; i < database_observer_ids.size(); i++) {
+    if (observers_.Lookup(database_observer_ids[i]) == observer.get()) {

[Marijn Kruisselbrink, 2016/06/24 00:48:09]

I'm confused about this check. observers_ owns WebIDBObserver instances, so it
should never be possible to have a unique_ptr that points to a WebIDBObserver
instance that is also in observers_ (if you would have such a pointer the
observer would end up being deleted twice, as it has two owners).

In other words, this check will always return false, or cause crashes.

+      observers_.Remove(database_observer_ids[i]);
+      observer_ids_to_remove.push_back(database_observer_ids[i]);
+    }
+  }
+  Send(new IndexedDBHostMsg_DatabaseUnobserve(ipc_database_id,
+                                              observer_ids_to_remove));
+  return observer_ids_to_remove;
+}
+
+void IndexedDBDispatcher::RemoveIDBObservers(
+    const std::vector<int32_t>& observer_ids_to_remove) {
+  for (uint32_t i = 0; i < observer_ids_to_remove.size(); i++) {
+    observers_.Remove(observer_ids_to_remove[i]);
+  }
+}
+
 void IndexedDBDispatcher::RequestIDBCursorAdvance(
     unsigned long count,
     WebIDBCallbacks* callbacks_ptr,
     int32_t ipc_cursor_id,
     int64_t transaction_id) {
   // Reset all cursor prefetch caches except for this cursor.
   ResetCursorPrefetchCaches(transaction_id, ipc_cursor_id);
 
   std::unique_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
 
@@ skipping 620 matching lines @@
   typedef std::map<int32_t, WebIDBCursorImpl*>::iterator Iterator;
   for (Iterator i = cursors_.begin(); i != cursors_.end(); ++i) {
     if (i->first == ipc_exception_cursor_id ||
         i->second->transaction_id() != transaction_id)
       continue;
     i->second->ResetPrefetchCache();
   }
 }
 
 }  // namespace content