Migrate //content/renderer/dom_storage to OnceCallback

Bug: 714018

Change-Id: I735449654310ff89ecd2f5e7a56a638eb6bf7a28
Reviewed-on: https://chromium-review.googlesource.com/970383
Commit-Queue: Joshua Bell <jsbell@chromium.org>
Reviewed-by: Joshua Bell <jsbell@chromium.org>
Reviewed-by: Marijn Kruisselbrink <mek@chromium.org>
Cr-Commit-Position: refs/heads/master@{#544910}

content/renderer/dom_storage/dom_storage_cached_area.cc

@@ -77,9 +77,9 @@ bool DOMStorageCachedArea::SetItem(int connection_id,
   virtual_time_pauser.PauseVirtualTime(true);
   ignore_key_mutations_[key]++;
   proxy_->SetItem(connection_id, key, value, old_value, page_url,
-                  base::Bind(&DOMStorageCachedArea::OnSetItemComplete,
-                             weak_factory_.GetWeakPtr(), key,
-                             base::Passed(std::move(virtual_time_pauser))));
+                  base::BindOnce(&DOMStorageCachedArea::OnSetItemComplete,
+                                 weak_factory_.GetWeakPtr(), key,
+                                 std::move(virtual_time_pauser)));
   return true;
 }
 
@@ -105,9 +105,9 @@ void DOMStorageCachedArea::RemoveItem(int connection_id,
   ignore_key_mutations_[key]++;
   proxy_->RemoveItem(connection_id, key,
                      base::NullableString16(old_value, false), page_url,
-                     base::Bind(&DOMStorageCachedArea::OnRemoveItemComplete,
-                                weak_factory_.GetWeakPtr(), key,
-                                base::Passed(std::move(virtual_time_pauser))));
+                     base::BindOnce(&DOMStorageCachedArea::OnRemoveItemComplete,
+                                    weak_factory_.GetWeakPtr(), key,
+                                    std::move(virtual_time_pauser)));
 }
 
 void DOMStorageCachedArea::Clear(int connection_id, const GURL& page_url) {
@@ -121,9 +121,9 @@ void DOMStorageCachedArea::Clear(int connection_id, const GURL& page_url) {
   virtual_time_pauser.PauseVirtualTime(true);
   ignore_all_mutations_ = true;
   proxy_->ClearArea(connection_id, page_url,
-                    base::Bind(&DOMStorageCachedArea::OnClearComplete,
-                               weak_factory_.GetWeakPtr(),
-                               base::Passed(std::move(virtual_time_pauser))));
+                    base::BindOnce(&DOMStorageCachedArea::OnClearComplete,
+                                   weak_factory_.GetWeakPtr(),
+                                   std::move(virtual_time_pauser)));
 }
 
 void DOMStorageCachedArea::ApplyMutation(
@@ -182,10 +182,9 @@ void DOMStorageCachedArea::Prime(int connection_id) {
   ignore_all_mutations_ = true;
   DOMStorageValuesMap values;
   base::TimeTicks before = base::TimeTicks::Now();
-  proxy_->LoadArea(connection_id,
-                   &values,
-                   base::Bind(&DOMStorageCachedArea::OnLoadComplete,
-                              weak_factory_.GetWeakPtr()));
+  proxy_->LoadArea(connection_id, &values,
+                   base::BindOnce(&DOMStorageCachedArea::OnLoadComplete,
+                                  weak_factory_.GetWeakPtr()));
   base::TimeDelta time_to_prime = base::TimeTicks::Now() - before;
   // Keeping this histogram named the same (without the ForRenderer suffix)
   // to maintain histogram continuity.

content/renderer/dom_storage/dom_storage_cached_area_unittest.cc

@@ -29,8 +29,8 @@ class MockProxy : public DOMStorageProxy {
 
   void LoadArea(int connection_id,
                 DOMStorageValuesMap* values,
-                const CompletionCallback& callback) override {
-    pending_callbacks_.push_back(callback);
+                CompletionCallback callback) override {
+    pending_callbacks_.push_back(std::move(callback));
     observed_load_area_ = true;
     observed_connection_id_ = connection_id;
     *values = load_area_return_values_;
@@ -41,8 +41,8 @@ class MockProxy : public DOMStorageProxy {
                const base::string16& value,
                const base::NullableString16& old_value,
                const GURL& page_url,
-               const CompletionCallback& callback) override {
-    pending_callbacks_.push_back(callback);
+               CompletionCallback callback) override {
+    pending_callbacks_.push_back(std::move(callback));
     observed_set_item_ = true;
     observed_connection_id_ = connection_id;
     observed_key_ = key;
@@ -54,8 +54,8 @@ class MockProxy : public DOMStorageProxy {
                   const base::string16& key,
                   const base::NullableString16& old_value,
                   const GURL& page_url,
-                  const CompletionCallback& callback) override {
-    pending_callbacks_.push_back(callback);
+                  CompletionCallback callback) override {
+    pending_callbacks_.push_back(std::move(callback));
     observed_remove_item_ = true;
     observed_connection_id_ = connection_id;
     observed_key_ = key;
@@ -64,8 +64,8 @@ class MockProxy : public DOMStorageProxy {
 
   void ClearArea(int connection_id,
                  const GURL& page_url,
-                 const CompletionCallback& callback) override {
-    pending_callbacks_.push_back(callback);
+                 CompletionCallback callback) override {
+    pending_callbacks_.push_back(std::move(callback));
     observed_clear_area_ = true;
     observed_connection_id_ = connection_id;
     observed_page_url_ = page_url;
@@ -91,7 +91,7 @@ class MockProxy : public DOMStorageProxy {
 
   void CompleteOnePendingCallback(bool success) {
     ASSERT_TRUE(!pending_callbacks_.empty());
-    pending_callbacks_.front().Run(success);
+    std::move(pending_callbacks_.front()).Run(success);
     pending_callbacks_.pop_front();
   }
 

content/renderer/dom_storage/dom_storage_dispatcher.cc

@@ -110,21 +110,21 @@ class DomStorageDispatcher::ProxyImpl : public DOMStorageProxy {
   // DOMStorageProxy interface for use by DOMStorageCachedArea.
   void LoadArea(int connection_id,
                 DOMStorageValuesMap* values,
-                const CompletionCallback& callback) override;
+                CompletionCallback callback) override;
   void SetItem(int connection_id,
                const base::string16& key,
                const base::string16& value,
                const base::NullableString16& old_value,
                const GURL& page_url,
-               const CompletionCallback& callback) override;
+               CompletionCallback callback) override;
   void RemoveItem(int connection_id,
                   const base::string16& key,
                   const base::NullableString16& old_value,
                   const GURL& page_url,
-                  const CompletionCallback& callback) override;
+                  CompletionCallback callback) override;
   void ClearArea(int connection_id,
                  const GURL& page_url,
-                 const CompletionCallback& callback) override;
+                 CompletionCallback callback) override;
 
  private:
   // Struct to hold references to our contained areas and
@@ -141,7 +141,7 @@ class DomStorageDispatcher::ProxyImpl : public DOMStorageProxy {
 
   ~ProxyImpl() override {}
 
-  void PushPendingCallback(const CompletionCallback& callback) {
+  void PushPendingCallback(CompletionCallback callback) {
     // Terminate the renderer if an excessive number of calls are made,
     // This is indicative of script in an infinite loop or being malicious.
     // It's better to crash intentionally than by running the system OOM
@@ -154,11 +154,11 @@ class DomStorageDispatcher::ProxyImpl : public DOMStorageProxy {
     // to more reliably commit changes during shutdown.
     if (pending_callbacks_.empty())
       blink::Platform::Current()->SuddenTerminationChanged(false);
-    pending_callbacks_.push_back(callback);
+    pending_callbacks_.push_back(std::move(callback));
   }
 
   CompletionCallback PopPendingCallback() {
-    CompletionCallback callback = pending_callbacks_.front();
+    CompletionCallback callback = std::move(pending_callbacks_.front());
     pending_callbacks_.pop_front();
     if (pending_callbacks_.empty())
       blink::Platform::Current()->SuddenTerminationChanged(true);
@@ -238,10 +238,10 @@ void DomStorageDispatcher::ProxyImpl::Shutdown() {
   pending_callbacks_.clear();
 }
 
-void DomStorageDispatcher::ProxyImpl::LoadArea(
-    int connection_id, DOMStorageValuesMap* values,
-    const CompletionCallback& callback) {
-  PushPendingCallback(callback);
+void DomStorageDispatcher::ProxyImpl::LoadArea(int connection_id,
+                                               DOMStorageValuesMap* values,
+                                               CompletionCallback callback) {
+  PushPendingCallback(std::move(callback));
   throttling_filter_->SendThrottled(new DOMStorageHostMsg_LoadStorageArea(
       connection_id, values));
 }
@@ -252,8 +252,8 @@ void DomStorageDispatcher::ProxyImpl::SetItem(
     const base::string16& value,
     const base::NullableString16& old_value,
     const GURL& page_url,
-    const CompletionCallback& callback) {
-  PushPendingCallback(callback);
+    CompletionCallback callback) {
+  PushPendingCallback(std::move(callback));
   throttling_filter_->SendThrottled(new DOMStorageHostMsg_SetItem(
       connection_id, key, value, old_value, page_url));
 }
@@ -263,16 +263,16 @@ void DomStorageDispatcher::ProxyImpl::RemoveItem(
     const base::string16& key,
     const base::NullableString16& old_value,
     const GURL& page_url,
-    const CompletionCallback& callback) {
-  PushPendingCallback(callback);
+    CompletionCallback callback) {
+  PushPendingCallback(std::move(callback));
   throttling_filter_->SendThrottled(new DOMStorageHostMsg_RemoveItem(
       connection_id, key, old_value, page_url));
 }
 
 void DomStorageDispatcher::ProxyImpl::ClearArea(int connection_id,
-                      const GURL& page_url,
-                      const CompletionCallback& callback) {
-  PushPendingCallback(callback);
+                                                const GURL& page_url,
+                                                CompletionCallback callback) {
+  PushPendingCallback(std::move(callback));
   throttling_filter_->SendThrottled(new DOMStorageHostMsg_Clear(
       connection_id, page_url));
 }

content/renderer/dom_storage/dom_storage_proxy.h

@@ -17,28 +17,28 @@ namespace content {
 // Abstract interface for cached area, renderer to browser communications.
 class DOMStorageProxy : public base::RefCounted<DOMStorageProxy> {
  public:
-  typedef base::Callback<void(bool)> CompletionCallback;
+  typedef base::OnceCallback<void(bool)> CompletionCallback;
 
   virtual void LoadArea(int connection_id,
                         DOMStorageValuesMap* values,
-                        const CompletionCallback& callback) = 0;
+                        CompletionCallback callback) = 0;
 
   virtual void SetItem(int connection_id,
                        const base::string16& key,
                        const base::string16& value,
                        const base::NullableString16& old_value,
                        const GURL& page_url,
-                       const CompletionCallback& callback) = 0;
+                       CompletionCallback callback) = 0;
 
   virtual void RemoveItem(int connection_id,
                           const base::string16& key,
                           const base::NullableString16& old_value,
                           const GURL& page_url,
-                          const CompletionCallback& callback) = 0;
+                          CompletionCallback callback) = 0;
 
   virtual void ClearArea(int connection_id,
                          const GURL& page_url,
-                         const CompletionCallback& callback) = 0;
+                         CompletionCallback callback) = 0;
 
  protected:
   friend class base::RefCounted<DOMStorageProxy>;

content/renderer/dom_storage/local_storage_cached_area.cc

@@ -32,20 +32,21 @@ enum class StorageFormat : uint8_t { UTF16 = 0, Latin1 = 1 };
 class GetAllCallback : public mojom::LevelDBWrapperGetAllCallback {
  public:
   static mojom::LevelDBWrapperGetAllCallbackAssociatedPtrInfo CreateAndBind(
-      const base::Callback<void(bool)>& callback) {
+      base::OnceCallback<void(bool)> callback) {
     mojom::LevelDBWrapperGetAllCallbackAssociatedPtrInfo ptr_info;
     auto request = mojo::MakeRequest(&ptr_info);
     mojo::MakeStrongAssociatedBinding(
-        base::WrapUnique(new GetAllCallback(callback)), std::move(request));
+        base::WrapUnique(new GetAllCallback(std::move(callback))),
+        std::move(request));
     return ptr_info;
   }
 
  private:
-  explicit GetAllCallback(const base::Callback<void(bool)>& callback)
-      : m_callback(callback) {}
-  void Complete(bool success) override { m_callback.Run(success); }
+  explicit GetAllCallback(base::OnceCallback<void(bool)> callback)
+      : m_callback(std::move(callback)) {}
+  void Complete(bool success) override { std::move(m_callback).Run(success); }
 
-  base::Callback<void(bool)> m_callback;
+  base::OnceCallback<void(bool)> m_callback;
 };
 
 }  // namespace
@@ -428,8 +429,8 @@ void LocalStorageCachedArea::EnsureLoaded() {
   leveldb::mojom::DatabaseError status = leveldb::mojom::DatabaseError::OK;
   std::vector<content::mojom::KeyValuePtr> data;
   leveldb_->GetAll(GetAllCallback::CreateAndBind(
-                       base::Bind(&LocalStorageCachedArea::OnGetAllComplete,
-                                  weak_factory_.GetWeakPtr())),
+                       base::BindOnce(&LocalStorageCachedArea::OnGetAllComplete,
+                                      weak_factory_.GetWeakPtr())),
                    &status, &data);
 
   DOMStorageValuesMap values;