Change scoped_ptr to std::unique_ptr in //net.

net/tools/get_server_time/get_server_time.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.
 
 // This is a small utility that snarfs the server time from the
 // response headers of an http/https HEAD request and compares it to
 // the local time.
 //
 // TODO(akalin): Also snarf the server time from the TLS handshake, if
 // any (http://crbug.com/146090).
 
 #include <cstdio>
 #include <cstdlib>
+#include <memory>
 #include <string>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/format_macros.h"
 #include "base/i18n/time_formatting.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/log/net_log.h"
@@ skipping 76 matching lines @@
     // to VLOG(1).
     if (!VLOG_IS_ON(1))
       return;
 
     const char* const source_type =
         net::NetLog::SourceTypeToString(entry.source().type);
     const char* const event_type =
         net::NetLog::EventTypeToString(entry.type());
     const char* const event_phase =
         net::NetLog::EventPhaseToString(entry.phase());
-    scoped_ptr<base::Value> params(entry.ParametersToValue());
+    std::unique_ptr<base::Value> params(entry.ParametersToValue());
     std::string params_str;
     if (params.get()) {
       base::JSONWriter::Write(*params, &params_str);
       params_str.insert(0, ": ");
     }
 
     VLOG(1) << source_type << "(" << entry.source().id << "): "
             << event_type << ": " << event_phase << params_str;
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PrintingLogObserver);
 };
 
 // Builds a URLRequestContext assuming there's only a single loop.
-scoped_ptr<net::URLRequestContext>
-BuildURLRequestContext(net::NetLog* net_log) {
+std::unique_ptr<net::URLRequestContext> BuildURLRequestContext(
+    net::NetLog* net_log) {
   net::URLRequestContextBuilder builder;
 #if defined(OS_LINUX)
   // On Linux, use a fixed ProxyConfigService, since the default one
   // depends on glib.
   //
   // TODO(akalin): Remove this once http://crbug.com/146421 is fixed.
   builder.set_proxy_config_service(
-      make_scoped_ptr(new net::ProxyConfigServiceFixed(net::ProxyConfig())));
+      base::WrapUnique(new net::ProxyConfigServiceFixed(net::ProxyConfig())));
 #endif
-  scoped_ptr<net::URLRequestContext> context(builder.Build());
+  std::unique_ptr<net::URLRequestContext> context(builder.Build());
   context->set_net_log(net_log);
   return context;
 }
 
 // Assuming that the time |server_time| was received from a server,
 // that the request for the server was started on |start_ticks|, and
 // that it ended on |end_ticks|, fills |server_now| with an estimate
 // of the current time and |server_now_uncertainty| with a
 // conservative estimate of the uncertainty.
 void EstimateServerTimeNow(base::Time server_time,
@@ skipping 63 matching lines @@
   // The declaration order for net_log and printing_log_observer is
   // important. The destructor of PrintingLogObserver removes itself
   // from net_log, so net_log must be available for entire lifetime of
   // printing_log_observer.
   net::NetLog net_log;
   PrintingLogObserver printing_log_observer;
   net_log.DeprecatedAddObserver(&printing_log_observer,
                                 net::NetLogCaptureMode::IncludeSocketBytes());
 
   QuitDelegate delegate;
-  scoped_ptr<net::URLFetcher> fetcher =
+  std::unique_ptr<net::URLFetcher> fetcher =
       net::URLFetcher::Create(url, net::URLFetcher::HEAD, &delegate);
-  scoped_ptr<net::URLRequestContext> url_request_context(
+  std::unique_ptr<net::URLRequestContext> url_request_context(
       BuildURLRequestContext(&net_log));
   fetcher->SetRequestContext(
       // Since there's only a single thread, there's no need to worry
       // about when the URLRequestContext gets created.
       // The URLFetcher will take a reference on the object, and hence
       // implicitly take ownership.
       new net::TrivialURLRequestContextGetter(url_request_context.get(),
                                               main_loop.task_runner()));
   const base::Time start_time = base::Time::Now();
   const base::TimeTicks start_ticks = base::TimeTicks::Now();
@@ skipping 71 matching lines @@
                &skew, &skew_uncertainty);
 
   std::printf(
       "An estimate for the local clock skew is %.2f ms with "
       "uncertainty %.2f ms\n",
       skew.InMillisecondsF(),
       skew_uncertainty.InMillisecondsF());
 
   return EXIT_SUCCESS;
 }