[Sync] Rewriting ".reset(new" pattern to use "= base::MakeUnique" instead.

chrome/browser/sync/test/integration/sync_test.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/sync/test/integration/sync_test.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 336 matching lines @@
   }
   base::FilePath profile_path = tmp_profile_paths_[index]->GetPath();
   if (UsingExternalServers()) {
     // If running against an EXTERNAL_LIVE_SERVER, we signin profiles using real
     // GAIA server. This requires creating profiles with no test hooks.
     InitializeProfile(index, MakeProfileForUISignin(profile_path));
   } else {
     // Without need of real GAIA authentication, we create new test profiles.
     // For test profiles, a custom delegate needs to be used to do the
     // initialization work before the profile is registered.
-    profile_delegates_[index].reset(new SyncProfileDelegate(base::Bind(
-            &SyncTest::InitializeProfile, base::Unretained(this), index)));
+    profile_delegates_[index] =
+        base::MakeUnique<SyncProfileDelegate>(base::Bind(
+            &SyncTest::InitializeProfile, base::Unretained(this), index));
     MakeTestProfile(profile_path, index);
   }
 
   // Once profile initialization has kicked off, wait for it to finish.
   WaitForDataModels(GetProfile(index));
 }
 
 // Called when the ProfileManager has created a profile.
 // static
 void SyncTest::CreateProfileCallback(const base::Closure& quit_closure,
@@ skipping 131 matching lines @@
   }
 
   // Verifier account is not useful when running against external servers.
   if (UsingExternalServers())
     DisableVerifier();
 
   // Create the verifier profile.
   if (use_verifier_) {
     base::FilePath user_data_dir;
     PathService::Get(chrome::DIR_USER_DATA, &user_data_dir);
-    profile_delegates_[num_clients_].reset(
-        new SyncProfileDelegate(base::Callback<void(Profile*)>()));
+    profile_delegates_[num_clients_] =
+        base::MakeUnique<SyncProfileDelegate>(base::Callback<void(Profile*)>());
     verifier_ = MakeTestProfile(
         user_data_dir.Append(FILE_PATH_LITERAL("Verifier")), num_clients_);
     WaitForDataModels(verifier());
   }
   // Error cases are all handled by LOG(FATAL) messages. So there is not really
   // a case that returns false.  In case we failed to create a verifier profile,
   // any call to the verifier() would fail.
   return true;
 }
 
@@ skipping 172 matching lines @@
 
   // Allow connection to googleapis.com for oauth token requests in E2E tests.
   resolver->AllowDirectLookup("*.googleapis.com");
 
   // On Linux, we use Chromium's NSS implementation which uses the following
   // hosts for certificate verification. Without these overrides, running the
   // integration tests on Linux causes error as we make external DNS lookups.
   resolver->AllowDirectLookup("*.thawte.com");
   resolver->AllowDirectLookup("*.geotrust.com");
   resolver->AllowDirectLookup("*.gstatic.com");
-  mock_host_resolver_override_.reset(
-      new net::ScopedDefaultHostResolverProc(resolver));
+  mock_host_resolver_override_ =
+      base::MakeUnique<net::ScopedDefaultHostResolverProc>(resolver);
 }
 
 void SyncTest::TearDownInProcessBrowserTestFixture() {
   mock_host_resolver_override_.reset();
 }
 
 void SyncTest::WaitForDataModels(Profile* profile) {
   bookmarks::test::WaitForBookmarkModelToLoad(
       BookmarkModelFactory::GetForBrowserContext(profile));
   ui_test_utils::WaitForHistoryToLoad(HistoryServiceFactory::GetForProfile(
@@ skipping 15 matching lines @@
   std::vector<std::string> tokens = base::SplitString(
       file_contents, "\r\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   ASSERT_EQ(2U, tokens.size()) << "Password file \""
       << password_file_.value()
       << "\" must contain exactly two lines of text.";
   username_ = tokens[0];
   password_ = tokens[1];
 }
 
 void SyncTest::SetupMockGaiaResponses() {
-  factory_.reset(new net::URLFetcherImplFactory());
-  fake_factory_.reset(new net::FakeURLFetcherFactory(factory_.get()));
+  factory_ = base::MakeUnique<net::URLFetcherImplFactory>();
+  fake_factory_ = base::MakeUnique<net::FakeURLFetcherFactory>(factory_.get());
   fake_factory_->SetFakeResponse(
       GaiaUrls::GetInstance()->get_user_info_url(),
       "email=user@gmail.com\ndisplayEmail=user@gmail.com",
       net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
   fake_factory_->SetFakeResponse(
       GaiaUrls::GetInstance()->issue_auth_token_url(),
       "auth",
       net::HTTP_OK,
       net::URLRequestStatus::SUCCESS);
@@ skipping 108 matching lines @@
     if (!SetUpLocalPythonTestServer())
       LOG(FATAL) << "Failed to set up local python sync and XMPP servers";
     SetupMockGaiaResponses();
   } else if (server_type_ == LOCAL_LIVE_SERVER) {
     // Using mock gaia credentials requires the use of a mock XMPP server.
     if (username_ == "user@gmail.com" && !SetUpLocalPythonTestServer())
       LOG(FATAL) << "Failed to set up local python XMPP server";
     if (!SetUpLocalTestServer())
       LOG(FATAL) << "Failed to set up local test server";
   } else if (server_type_ == IN_PROCESS_FAKE_SERVER) {
-    fake_server_.reset(new fake_server::FakeServer());
+    fake_server_ = base::MakeUnique<fake_server::FakeServer>();
     SetupMockGaiaResponses();
   } else {
     LOG(FATAL) << "Don't know which server environment to run test in.";
   }
 }
 
 bool SyncTest::SetUpLocalPythonTestServer() {
   EXPECT_TRUE(sync_server_.Start())
       << "Could not launch local python test server.";
 
   base::CommandLine* cl = base::CommandLine::ForCurrentProcess();
   if (server_type_ == LOCAL_PYTHON_SERVER) {
     std::string sync_service_url = sync_server_.GetURL("chromiumsync").spec();
     cl->AppendSwitchASCII(switches::kSyncServiceURL, sync_service_url);
     DVLOG(1) << "Started local python sync server at " << sync_service_url;
   }
 
   int xmpp_port = 0;
   if (!sync_server_.server_data().GetInteger("xmpp_port", &xmpp_port)) {
     LOG(ERROR) << "Could not find valid xmpp_port value";
     return false;
   }
   if ((xmpp_port <= 0) || (xmpp_port > std::numeric_limits<uint16_t>::max())) {
     LOG(ERROR) << "Invalid xmpp port: " << xmpp_port;
     return false;
   }
 
   net::HostPortPair xmpp_host_port_pair(sync_server_.host_port_pair());
   xmpp_host_port_pair.set_port(xmpp_port);
-  xmpp_port_.reset(new net::ScopedPortException(xmpp_port));
+  xmpp_port_ = base::MakeUnique<net::ScopedPortException>(xmpp_port);
 
   if (!cl->HasSwitch(invalidation::switches::kSyncNotificationHostPort)) {
     cl->AppendSwitchASCII(invalidation::switches::kSyncNotificationHostPort,
                           xmpp_host_port_pair.ToString());
     // The local XMPP server only supports insecure connections.
     cl->AppendSwitch(invalidation::switches::kSyncAllowInsecureXmppConnection);
   }
   DVLOG(1) << "Started local python XMPP server at "
            << xmpp_host_port_pair.ToString();
 
@@ skipping 215 matching lines @@
 
 void SyncTest::TriggerSyncForModelTypes(int index,
                                         syncer::ModelTypeSet model_types) {
   GetSyncService(index)->TriggerRefresh(model_types);
 }
 
 void SyncTest::SetPreexistingPreferencesFileContents(
     const std::string& contents) {
   preexisting_preferences_file_contents_ = contents;
 }