Convert //remoting to use std::unique_ptr

remoting/host/policy_watcher_unittest.cc

 // Copyright 2015 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 "remoting/host/policy_watcher.h"
+
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/mock_log.h"
 #include "base/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "components/policy/core/common/fake_async_policy_loader.h"
 #include "policy/policy_constants.h"
 #include "remoting/host/dns_blackhole_checker.h"
-#include "remoting/host/policy_watcher.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 
 namespace key = ::policy::key;
 
 MATCHER_P(IsPolicies, dict, "") {
   bool equal = arg->Equals(dict);
   if (!equal) {
     std::string actual_value;
     base::JSONWriter::WriteWithOptions(
         *arg, base::JSONWriter::OPTIONS_PRETTY_PRINT, &actual_value);
 
     std::string expected_value;
     base::JSONWriter::WriteWithOptions(
         *dict, base::JSONWriter::OPTIONS_PRETTY_PRINT, &expected_value);
 
     *result_listener << "Policies are not equal. ";
     *result_listener << "Expected policy: " << expected_value << ". ";
     *result_listener << "Actual policy: " << actual_value << ".";
   }
   return equal;
 }
 
 class MockPolicyCallback {
  public:
   MockPolicyCallback(){};
 
-  // TODO(lukasza): gmock cannot mock a method taking scoped_ptr<T>...
+  // TODO(lukasza): gmock cannot mock a method taking std::unique_ptr<T>...
   MOCK_METHOD1(OnPolicyUpdatePtr, void(const base::DictionaryValue* policies));
-  void OnPolicyUpdate(scoped_ptr<base::DictionaryValue> policies) {
+  void OnPolicyUpdate(std::unique_ptr<base::DictionaryValue> policies) {
     OnPolicyUpdatePtr(policies.get());
   }
 
   MOCK_METHOD0(OnPolicyError, void());
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockPolicyCallback);
 };
 
 class PolicyWatcherTest : public testing::Test {
  public:
   PolicyWatcherTest() : message_loop_(base::MessageLoop::TYPE_IO) {}
 
   void SetUp() override {
     // We expect no callbacks unless explicitly specified by individual tests.
     EXPECT_CALL(mock_policy_callback_, OnPolicyUpdatePtr(testing::_)).Times(0);
     EXPECT_CALL(mock_policy_callback_, OnPolicyError()).Times(0);
 
     // Retaining a raw pointer to keep control over policy contents.
     policy_loader_ =
         new policy::FakeAsyncPolicyLoader(base::ThreadTaskRunnerHandle::Get());
     policy_watcher_ =
-        PolicyWatcher::CreateFromPolicyLoader(make_scoped_ptr(policy_loader_));
+        PolicyWatcher::CreateFromPolicyLoader(base::WrapUnique(policy_loader_));
 
     nat_true_.SetBoolean(key::kRemoteAccessHostFirewallTraversal, true);
     nat_false_.SetBoolean(key::kRemoteAccessHostFirewallTraversal, false);
     nat_one_.SetInteger(key::kRemoteAccessHostFirewallTraversal, 1);
     nat_one_domain_full_.SetInteger(key::kRemoteAccessHostFirewallTraversal, 1);
     nat_one_domain_full_.SetString(key::kRemoteAccessHostDomain, kHostDomain);
     domain_empty_.SetString(key::kRemoteAccessHostDomain, std::string());
     domain_full_.SetString(key::kRemoteAccessHostDomain, kHostDomain);
     SetDefaults(nat_true_others_default_);
     nat_true_others_default_.SetBoolean(key::kRemoteAccessHostFirewallTraversal,
@@ skipping 108 matching lines @@
 
   static const char* kHostDomain;
   static const char* kPortRange;
   base::MessageLoop message_loop_;
   MockPolicyCallback mock_policy_callback_;
 
   // |policy_loader_| is owned by |policy_watcher_|. PolicyWatcherTest retains
   // a raw pointer to |policy_loader_| in order to control the simulated / faked
   // policy contents.
   policy::FakeAsyncPolicyLoader* policy_loader_;
-  scoped_ptr<PolicyWatcher> policy_watcher_;
+  std::unique_ptr<PolicyWatcher> policy_watcher_;
 
   base::DictionaryValue empty_;
   base::DictionaryValue nat_true_;
   base::DictionaryValue nat_false_;
   base::DictionaryValue nat_one_;
   base::DictionaryValue nat_one_domain_full_;
   base::DictionaryValue domain_empty_;
   base::DictionaryValue domain_full_;
   base::DictionaryValue nat_true_others_default_;
   base::DictionaryValue nat_false_others_default_;
@@ skipping 432 matching lines @@
 
   // And check one, random "boolean" policy to see if the type propagated
   // correctly from policy_templates.json file.
   const policy::Schema boolean_schema =
       schema->GetKnownProperty("RemoteAccessHostRequireCurtain");
   EXPECT_TRUE(boolean_schema.valid());
   EXPECT_EQ(boolean_schema.type(), base::Value::Type::TYPE_BOOLEAN);
 }
 
 }  // namespace remoting