Switch base::Value typemapping to be by value instead of by unique_ptr.

services/preferences/persistent_pref_store_impl.cc

 // Copyright 2017 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 "services/preferences/persistent_pref_store_impl.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/memory/ptr_util.h"
@@ skipping 24 matching lines @@
   ~Connection() override = default;
 
   void OnPrefValuesChanged(const std::vector<mojom::PrefUpdatePtr>& updates) {
     if (write_in_progress_)
       return;
 
     std::vector<mojom::PrefUpdatePtr> filtered_updates;
     for (const auto& update : updates) {
       if (base::ContainsKey(observed_keys_, update->key)) {
         filtered_updates.push_back(mojom::PrefUpdate::New(
-            update->key,
-            update->value ? update->value->CreateDeepCopy() : nullptr, 0));
+            update->key, update->value ? update->value : base::nullopt, 0));
       }
     }
     if (!filtered_updates.empty())
       observer_->OnPrefsChanged(std::move(filtered_updates));
   }
 
  private:
   // mojom::PersistentPrefStore:
   void SetValues(std::vector<mojom::PrefUpdatePtr> updates) override {
     base::AutoReset<bool> scoped_call_in_progress(&write_in_progress_, true);
@@ skipping 48 matching lines @@
   mojom::PersistentPrefStorePtr pref_store_ptr;
   mojom::PrefStoreObserverPtr observer;
   mojom::PrefStoreObserverRequest observer_request =
       mojo::MakeRequest(&observer);
   auto connection = base::MakeUnique<Connection>(
       this, mojo::MakeRequest(&pref_store_ptr), std::move(observer),
       std::move(observed_prefs));
   auto* connection_ptr = connection.get();
   connections_.insert(std::make_pair(connection_ptr, std::move(connection)));
   return mojom::PersistentPrefStoreConnection::New(
-      mojom::PrefStoreConnection::New(std::move(observer_request),
-                                      backing_pref_store_->GetValues(), true),
+      mojom::PrefStoreConnection::New(
+          std::move(observer_request),
+          std::move(*backing_pref_store_->GetValues()), true),
       std::move(pref_store_ptr), backing_pref_store_->GetReadError(),
       backing_pref_store_->ReadOnly());
 }
 
 void PersistentPrefStoreImpl::OnPrefValueChanged(const std::string& key) {}
 
 void PersistentPrefStoreImpl::OnInitializationCompleted(bool succeeded) {
   DCHECK(initializing_);
   backing_pref_store_->RemoveObserver(this);
   initializing_ = false;
   std::move(on_initialized_).Run();
 }
 
 void PersistentPrefStoreImpl::SetValues(
     std::vector<mojom::PrefUpdatePtr> updates) {
   for (auto& entry : connections_)
     entry.first->OnPrefValuesChanged(updates);
 
   for (auto& update : updates) {
     if (update->value) {
-      backing_pref_store_->SetValue(update->key, std::move(update->value),
-                                    update->flags);
+      backing_pref_store_->SetValue(
+          update->key, update->value->CreateDeepCopy(), update->flags);
     } else {
       backing_pref_store_->RemoveValue(update->key, update->flags);
     }
   }
 }
 
 void PersistentPrefStoreImpl::CommitPendingWrite() {
   backing_pref_store_->CommitPendingWrite();
 }
 
 void PersistentPrefStoreImpl::SchedulePendingLossyWrites() {
   backing_pref_store_->SchedulePendingLossyWrites();
 }
 
 void PersistentPrefStoreImpl::ClearMutableValues() {
   backing_pref_store_->ClearMutableValues();
 }
 
 void PersistentPrefStoreImpl::OnConnectionError(Connection* connection) {
   connections_.erase(connection);
 }
 
 }  // namespace prefs