Convert //components/data_reduction_proxy from scoped_ptr to std::unique_ptr

components/data_reduction_proxy/content/browser/content_lofi_decider_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 "components/data_reduction_proxy/content/browser/content_lofi_decider.h"
 

[megjablon, 2016/04/12 21:55:35]

#include <memory>

[dcheng, 2016/04/12 22:38:34]

Done.

 #include <stddef.h>
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
@@ skipping 51 matching lines @@
     context_.Init();
 
     test_context_ = DataReductionProxyTestContext::Builder()
                         .WithClient(kClient)
                         .WithMockClientSocketFactory(&mock_socket_factory_)
                         .WithURLRequestContext(&context_)
                         .Build();
 
     data_reduction_proxy_network_delegate_.reset(
         new DataReductionProxyNetworkDelegate(
-            scoped_ptr<net::NetworkDelegate>(new net::NetworkDelegateImpl()),
+            std::unique_ptr<net::NetworkDelegate>(
+                new net::NetworkDelegateImpl()),
             test_context_->config(),
             test_context_->io_data()->request_options(),
             test_context_->configurator()));
 
     data_reduction_proxy_network_delegate_->InitIODataAndUMA(
         test_context_->io_data(), test_context_->io_data()->bypass_stats());
 
     context_.set_network_delegate(data_reduction_proxy_network_delegate_.get());
 
-    scoped_ptr<data_reduction_proxy::ContentLoFiDecider>
+    std::unique_ptr<data_reduction_proxy::ContentLoFiDecider>
         data_reduction_proxy_lofi_decider(
             new data_reduction_proxy::ContentLoFiDecider());
     test_context_->io_data()->set_lofi_decider(
         std::move(data_reduction_proxy_lofi_decider));
   }
 
-  scoped_ptr<net::URLRequest> CreateRequest(bool is_using_lofi) {
-    scoped_ptr<net::URLRequest> request = context_.CreateRequest(
+  std::unique_ptr<net::URLRequest> CreateRequest(bool is_using_lofi) {
+    std::unique_ptr<net::URLRequest> request = context_.CreateRequest(
         GURL("http://www.google.com/"), net::IDLE, &delegate_);
 
     content::ResourceRequestInfo::AllocateForTesting(
         request.get(), content::RESOURCE_TYPE_SUB_FRAME, NULL, -1, -1, -1,
         false,  // is_main_frame
         false,  // parent_is_main_frame
         false,  // allow_download
         false,  // is_async
         is_using_lofi);
 
@@ skipping 48 matching lines @@
               header_value.find(
                   chrome_proxy_lo_fi_ignore_preview_blacklist_directive()) !=
                   std::string::npos);
   }
 
  protected:
   base::MessageLoopForIO message_loop_;
   net::MockClientSocketFactory mock_socket_factory_;
   net::TestURLRequestContext context_;
   net::TestDelegate delegate_;
-  scoped_ptr<DataReductionProxyTestContext> test_context_;
-  scoped_ptr<DataReductionProxyNetworkDelegate>
+  std::unique_ptr<DataReductionProxyTestContext> test_context_;
+  std::unique_ptr<DataReductionProxyNetworkDelegate>
       data_reduction_proxy_network_delegate_;
 };
 
 TEST_F(ContentLoFiDeciderTest, LoFiFlags) {
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
     bool is_using_previews;
   } tests[] = {
       {false, false}, {true, false}, {false, true}, {true, true},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    scoped_ptr<net::URLRequest> request = CreateRequest(tests[i].is_using_lofi);
+    std::unique_ptr<net::URLRequest> request =
+        CreateRequest(tests[i].is_using_lofi);
     base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
     command_line->InitFromArgv(command_line->argv());
     if (tests[i].is_using_previews) {
       command_line->AppendSwitch(
           switches::kEnableDataReductionProxyLoFiPreview);
     }
 
     // No flags or field trials. The Lo-Fi header should not be added.
     net::HttpRequestHeaders headers;
     NotifyBeforeSendProxyHeaders(&headers, request.get(), true);
@@ skipping 57 matching lines @@
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
   } tests[] = {
       {false}, {true},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    scoped_ptr<net::URLRequest> request = CreateRequest(tests[i].is_using_lofi);
+    std::unique_ptr<net::URLRequest> request =
+        CreateRequest(tests[i].is_using_lofi);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendProxyHeaders(&headers, request.get(), true);
     VerifyLoFiHeader(tests[i].is_using_lofi, headers);
     VerifyLoFiPreviewHeader(false, headers);
     VerifyLoFiIgnorePreviewBlacklistHeader(false, headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, LoFiControlFieldTrial) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Control");
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
   } tests[] = {
       {false}, {true},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    scoped_ptr<net::URLRequest> request = CreateRequest(tests[i].is_using_lofi);
+    std::unique_ptr<net::URLRequest> request =
+        CreateRequest(tests[i].is_using_lofi);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendProxyHeaders(&headers, request.get(), true);
     VerifyLoFiHeader(false, headers);
     VerifyLoFiPreviewHeader(false, headers);
     VerifyLoFiIgnorePreviewBlacklistHeader(false, headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, LoFiPreviewFieldTrial) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled_Preview");
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
     bool is_main_frame;
   } tests[] = {
       {false, false}, {true, false}, {false, true}, {true, true},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    scoped_ptr<net::URLRequest> request = CreateRequest(tests[i].is_using_lofi);
+    std::unique_ptr<net::URLRequest> request =
+        CreateRequest(tests[i].is_using_lofi);
     if (tests[i].is_main_frame)
       request->SetLoadFlags(request->load_flags() | net::LOAD_MAIN_FRAME);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendProxyHeaders(&headers, request.get(), true);
     VerifyLoFiHeader(false, headers);
     VerifyLoFiPreviewHeader(tests[i].is_using_lofi && tests[i].is_main_frame,
                             headers);
     VerifyLoFiIgnorePreviewBlacklistHeader(false, headers);
   }
 }
@@ skipping 29 matching lines @@
     }
 
     if (tests[i].auto_lofi_control_group) {
       base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                              "Control");
     }
 
     test_context_->config()->SetNetworkProhibitivelySlow(
         tests[i].network_prohibitively_slow);
 
-    scoped_ptr<net::URLRequest> request =
+    std::unique_ptr<net::URLRequest> request =
         CreateRequest(tests[i].network_prohibitively_slow);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendProxyHeaders(&headers, request.get(), true);
 
     VerifyLoFiHeader(expect_lofi_header, headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, SlowConnectionsFlag) {
   const struct {
@@ skipping 29 matching lines @@
 
     base::FieldTrialList field_trial_list(nullptr);
     if (tests[i].auto_lofi_enabled_group) {
       base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                              "Enabled");
     }
 
     test_context_->config()->SetNetworkProhibitivelySlow(
         tests[i].network_prohibitively_slow);
 
-    scoped_ptr<net::URLRequest> request =
+    std::unique_ptr<net::URLRequest> request =
         CreateRequest(tests[i].network_prohibitively_slow);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendProxyHeaders(&headers, request.get(), true);
 
     VerifyLoFiHeader(expect_lofi_header, headers);
   }
 }
 
 TEST_F(ContentLoFiDeciderTest, ProxyIsNotDataReductionProxy) {
   base::FieldTrialList field_trial_list(nullptr);
   base::FieldTrialList::CreateFieldTrial(params::GetLoFiFieldTrialName(),
                                          "Enabled");
   // Enable Lo-Fi.
   const struct {
     bool is_using_lofi;
   } tests[] = {
       {false}, {true},
   };
 
   for (size_t i = 0; i < arraysize(tests); ++i) {
-    scoped_ptr<net::URLRequest> request = CreateRequest(tests[i].is_using_lofi);
+    std::unique_ptr<net::URLRequest> request =
+        CreateRequest(tests[i].is_using_lofi);
     net::HttpRequestHeaders headers;
     NotifyBeforeSendProxyHeaders(&headers, request.get(), false);
     std::string header_value;
     headers.GetHeader(chrome_proxy_header(), &header_value);
     EXPECT_EQ(std::string::npos,
               header_value.find(chrome_proxy_lo_fi_directive()));
   }
 }
 
 }  // namespace data_reduction_roxy