Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

content/child/indexed_db/indexed_db_dispatcher.h

 // 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.
 
 #ifndef CONTENT_CHILD_INDEXED_DB_INDEXED_DB_DISPATCHER_H_
 #define CONTENT_CHILD_INDEXED_DB_INDEXED_DB_DISPATCHER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <map>
+#include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/gtest_prod_util.h"
 #include "base/id_map.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/nullable_string16.h"
 #include "content/child/indexed_db/indexed_db_callbacks_impl.h"
 #include "content/child/indexed_db/indexed_db_database_callbacks_impl.h"
 #include "content/common/content_export.h"
@@ skipping 52 matching lines @@
 
   // This method is virtual so it can be overridden in unit tests.
   virtual bool Send(IPC::Message* msg);
 
   int32_t RegisterObserver(std::unique_ptr<blink::WebIDBObserver> observer);
 
   // Removes observers from our local map observers_.
   void RemoveObservers(const std::vector<int32_t>& observer_ids_to_remove);
 
   // This method is virtual so it can be overridden in unit tests.
-  virtual void RequestIDBCursorAdvance(unsigned long count,
-                                       blink::WebIDBCallbacks* callbacks_ptr,
-                                       int32_t ipc_cursor_id,
-                                       int64_t transaction_id);
+  virtual void RequestIDBCursorAdvance(
+      unsigned long count,
+      std::unique_ptr<blink::WebIDBCallbacks> callbacks_ptr,
+      int32_t ipc_cursor_id,
+      int64_t transaction_id);
 
   // This method is virtual so it can be overridden in unit tests.
-  virtual void RequestIDBCursorContinue(const IndexedDBKey& key,
-                                        const IndexedDBKey& primary_key,
-                                        blink::WebIDBCallbacks* callbacks_ptr,
-                                        int32_t ipc_cursor_id,
-                                        int64_t transaction_id);
+  virtual void RequestIDBCursorContinue(
+      const IndexedDBKey& key,
+      const IndexedDBKey& primary_key,
+      std::unique_ptr<blink::WebIDBCallbacks> callbacks_ptr,
+      int32_t ipc_cursor_id,
+      int64_t transaction_id);
 
   // This method is virtual so it can be overridden in unit tests.
-  virtual void RequestIDBCursorPrefetch(int n,
-                                        blink::WebIDBCallbacks* callbacks_ptr,
-                                        int32_t ipc_cursor_id);
+  virtual void RequestIDBCursorPrefetch(
+      int n,
+      std::unique_ptr<blink::WebIDBCallbacks> callbacks_ptr,
+      int32_t ipc_cursor_id);
 
   // This method is virtual so it can be overridden in unit tests.
   virtual void RequestIDBCursorPrefetchReset(int used_prefetches,
                                              int unused_prefetches,
                                              int32_t ipc_cursor_id);
 
   void RegisterCursor(int32_t ipc_cursor_id, WebIDBCursorImpl* cursor);
 
   virtual void CursorDestroyed(int32_t ipc_cursor_id);
 
@@ skipping 12 matching lines @@
   void UnregisterMojoOwnedDatabaseCallbacks(
       blink::WebIDBDatabaseCallbacks* callback_state);
 
  private:
   FRIEND_TEST_ALL_PREFIXES(IndexedDBDispatcherTest, CursorReset);
   FRIEND_TEST_ALL_PREFIXES(IndexedDBDispatcherTest, CursorTransactionId);
 
   static int32_t CurrentWorkerId() { return WorkerThread::GetCurrentId(); }
 
   template <typename T>
-  void init_params(T* params, blink::WebIDBCallbacks* callbacks_ptr) {
-    std::unique_ptr<blink::WebIDBCallbacks> callbacks(callbacks_ptr);
+  void init_params(T* params,
+                   std::unique_ptr<blink::WebIDBCallbacks> callbacks_ptr) {
     params->ipc_thread_id = CurrentWorkerId();
-    params->ipc_callbacks_id = pending_callbacks_.Add(callbacks.release());
+    params->ipc_callbacks_id = pending_callbacks_.Add(std::move(callbacks_ptr));
   }
 
   // IDBCallback message handlers.
   void OnSuccessCursorContinue(
       const IndexedDBMsg_CallbacksSuccessCursorContinue_Params& p);
   void OnSuccessCursorPrefetch(
       const IndexedDBMsg_CallbacksSuccessCursorPrefetch_Params& p);
   void OnSuccessValue(const IndexedDBMsg_CallbacksSuccessValue_Params& p);
   void OnSuccessInteger(int32_t ipc_thread_id,
                         int32_t ipc_callbacks_id,
@@ skipping 29 matching lines @@
 
   // Map from cursor id to WebIDBCursorImpl.
   std::map<int32_t, WebIDBCursorImpl*> cursors_;
 
   DISALLOW_COPY_AND_ASSIGN(IndexedDBDispatcher);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_CHILD_INDEXED_DB_INDEXED_DB_DISPATCHER_H_