Re-write many calls to WrapUnique() with MakeUnique()

chrome/browser/extensions/api/storage/policy_value_store_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/extensions/api/storage/policy_value_store.h"
 
 #include <memory>
 
 #include "base/callback.h"
 #include "base/files/file_path.h"
@@ skipping 33 matching lines @@
 
 // Extends PolicyValueStore by overriding the mutating methods, so that the
 // Get() base implementation can be tested with the ValueStoreTest parameterized
 // tests.
 class MutablePolicyValueStore : public PolicyValueStore {
  public:
   explicit MutablePolicyValueStore(const base::FilePath& path)
       : PolicyValueStore(
             kTestExtensionId,
             make_scoped_refptr(new SettingsObserverList()),
-            base::WrapUnique(
-                new LeveldbValueStore(kDatabaseUMAClientName, path))) {}
+            base::MakeUnique<LeveldbValueStore>(kDatabaseUMAClientName, path)) {

[Devlin, 2016/08/29 15:10:01]

I thought git cl format preferred empty methods to be {}?

[Adam Rice, 2016/08/30 07:03:00]

I think it wrapped like this because '{' is the 80th character on the line.

+  }
   ~MutablePolicyValueStore() override {}
 
   WriteResult Set(WriteOptions options,
                   const std::string& key,
                   const base::Value& value) override {
     return delegate()->Set(options, key, value);
   }
 
   WriteResult Set(WriteOptions options,
                   const base::DictionaryValue& values) override {
@@ skipping 30 matching lines @@
   PolicyValueStoreTest()
       : file_thread_(content::BrowserThread::FILE, &loop_) {}
   ~PolicyValueStoreTest() override {}
 
   void SetUp() override {
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
     observers_ = new SettingsObserverList();
     observers_->AddObserver(&observer_);
     store_.reset(new PolicyValueStore(
         kTestExtensionId, observers_,
-        base::WrapUnique(new LeveldbValueStore(kDatabaseUMAClientName,
-                                               scoped_temp_dir_.path()))));
+        base::MakeUnique<LeveldbValueStore>(kDatabaseUMAClientName,
+                                            scoped_temp_dir_.path())));
   }
 
   void TearDown() override {
     observers_->RemoveObserver(&observer_);
     store_.reset();
   }
 
  protected:
   base::ScopedTempDir scoped_temp_dir_;
   base::MessageLoop loop_;
   content::TestBrowserThread file_thread_;
   std::unique_ptr<PolicyValueStore> store_;
   MockSettingsObserver observer_;
   scoped_refptr<SettingsObserverList> observers_;
 };
 
 TEST_F(PolicyValueStoreTest, DontProvideRecommendedPolicies) {
   policy::PolicyMap policies;
   base::FundamentalValue expected(123);
   policies.Set("must", policy::POLICY_LEVEL_MANDATORY,
                policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
                expected.CreateDeepCopy(), nullptr);
   policies.Set("may", policy::POLICY_LEVEL_RECOMMENDED,
                policy::POLICY_SCOPE_USER, policy::POLICY_SOURCE_CLOUD,
-               base::WrapUnique(new base::FundamentalValue(456)), nullptr);
+               base::MakeUnique<base::FundamentalValue>(456), nullptr);
   store_->SetCurrentPolicy(policies);
   ValueStore::ReadResult result = store_->Get();
   ASSERT_TRUE(result->status().ok());
   EXPECT_EQ(1u, result->settings().size());
   base::Value* value = NULL;
   EXPECT_FALSE(result->settings().Get("may", &value));
   EXPECT_TRUE(result->settings().Get("must", &value));
   EXPECT_TRUE(base::Value::Equals(&expected, value));
 }
 
@@ skipping 85 matching lines @@
   Mock::VerifyAndClearExpectations(&observer_);
 
   // Don't notify when there aren't any changes.
   EXPECT_CALL(observer_, OnSettingsChanged(_, _, _)).Times(0);
   store_->SetCurrentPolicy(policies);
   base::RunLoop().RunUntilIdle();
   Mock::VerifyAndClearExpectations(&observer_);
 }
 
 }  // namespace extensions