Mandate unique_ptr for base::IDMap in IDMapOwnPointer mode.

content/child/indexed_db/webidbcursor_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/webidbcursor_impl.h"
 
 #include <stddef.h>
 
+#include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "content/child/indexed_db/indexed_db_dispatcher.h"
 #include "content/child/indexed_db/indexed_db_key_builders.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/indexed_db/indexed_db_messages.h"
 #include "third_party/WebKit/public/platform/modules/indexeddb/WebIDBValue.h"
 
 using blink::WebBlobInfo;
 using blink::WebData;
@@ skipping 33 matching lines @@
 void WebIDBCursorImpl::advance(unsigned long count,
                                WebIDBCallbacks* callbacks_ptr) {
   IndexedDBDispatcher* dispatcher =
       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
   std::unique_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
   if (count <= prefetch_keys_.size()) {
     CachedAdvance(count, callbacks.get());
     return;
   }
   ResetPrefetchCache();
-  dispatcher->RequestIDBCursorAdvance(
-      count, callbacks.release(), ipc_cursor_id_, transaction_id_);
+  dispatcher->RequestIDBCursorAdvance(count, std::move(callbacks),
+                                      ipc_cursor_id_, transaction_id_);
 }
 
 void WebIDBCursorImpl::continueFunction(const WebIDBKey& key,
                                         WebIDBCallbacks* callbacks_ptr) {
   continueFunction(key, WebIDBKey::createNull(), callbacks_ptr);
 }
 
 void WebIDBCursorImpl::continueFunction(const WebIDBKey& key,
                                         const WebIDBKey& primary_key,
                                         WebIDBCallbacks* callbacks_ptr) {
   IndexedDBDispatcher* dispatcher =
       IndexedDBDispatcher::ThreadSpecificInstance(thread_safe_sender_.get());
   std::unique_ptr<WebIDBCallbacks> callbacks(callbacks_ptr);
 
   if (key.keyType() == blink::WebIDBKeyTypeNull &&
       primary_key.keyType() == blink::WebIDBKeyTypeNull) {
     // No key(s), so this would qualify for a prefetch.
     ++continue_count_;
 
     if (!prefetch_keys_.empty()) {
       // We have a prefetch cache, so serve the result from that.
       CachedContinue(callbacks.get());
       return;
     }
 
     if (continue_count_ > kPrefetchContinueThreshold) {
       // Request pre-fetch.
       ++pending_onsuccess_callbacks_;
       dispatcher->RequestIDBCursorPrefetch(
-          prefetch_amount_, callbacks.release(), ipc_cursor_id_);
+          prefetch_amount_, std::move(callbacks), ipc_cursor_id_);
 
       // Increase prefetch_amount_ exponentially.
       prefetch_amount_ *= 2;
       if (prefetch_amount_ > kMaxPrefetchAmount)
         prefetch_amount_ = kMaxPrefetchAmount;
 
       return;
     }
   } else {
     // Key argument supplied. We couldn't prefetch this.
     ResetPrefetchCache();
   }
 
-  dispatcher->RequestIDBCursorContinue(IndexedDBKeyBuilder::Build(key),
-                                       IndexedDBKeyBuilder::Build(primary_key),
-                                       callbacks.release(),
-                                       ipc_cursor_id_,
-                                       transaction_id_);
+  dispatcher->RequestIDBCursorContinue(
+      IndexedDBKeyBuilder::Build(key), IndexedDBKeyBuilder::Build(primary_key),
+      std::move(callbacks), ipc_cursor_id_, transaction_id_);
 }
 
 void WebIDBCursorImpl::postSuccessHandlerCallback() {
   pending_onsuccess_callbacks_--;
 
   // If the onsuccess callback called continue()/advance() on the cursor
   // again, and that request was served by the prefetch cache, then
   // pending_onsuccess_callbacks_ would be incremented. If not, it means the
   // callback did something else, or nothing at all, in which case we need to
   // reset the cache.
@@ skipping 85 matching lines @@
 
   // Reset the prefetch cache.
   prefetch_keys_.clear();
   prefetch_primary_keys_.clear();
   prefetch_values_.clear();
 
   pending_onsuccess_callbacks_ = 0;
 }
 
 }  // namespace content