Use modified URLRequest::Read() and delegate methods in components/

components/data_reduction_proxy/core/browser/data_reduction_proxy_bypass_stats_unittest.cc

 // Copyright 2014 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/core/browser/data_reduction_proxy_bypass_stats.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 161 matching lines @@
         .WillRepeatedly(testing::Return(
             test_case.fallback_proxy_server_is_data_reduction_proxy));
     EXPECT_CALL(*config(), WasDataReductionProxyUsed(url_request(), testing::_))
         .WillRepeatedly(testing::Return(test_case.was_proxy_used));
 
     std::unique_ptr<DataReductionProxyBypassStats> bypass_stats =
         BuildBypassStats();
 
     bypass_stats->OnProxyFallback(fallback_proxy_server,
                                   net::ERR_PROXY_CONNECTION_FAILED);
-    bypass_stats->OnUrlRequestCompleted(url_request(), false);
+    bypass_stats->OnUrlRequestCompleted(url_request(), false, net::OK);
     RunUntilIdle();
 
     EXPECT_EQ(test_case.is_unreachable, IsUnreachable());
   }
 }
 
 TEST_F(DataReductionProxyBypassStatsTest, ProxyUnreachableThenReachable) {
   net::ProxyServer fallback_proxy_server =
       net::ProxyServer::FromURI("foo.com", net::ProxyServer::SCHEME_HTTP);
   std::unique_ptr<DataReductionProxyBypassStats> bypass_stats =
       BuildBypassStats();
   EXPECT_CALL(*config(), IsDataReductionProxy(testing::_, testing::_))
       .WillOnce(testing::Return(true));
   EXPECT_CALL(*config(), WasDataReductionProxyUsed(url_request(), testing::_))
       .WillOnce(testing::Return(true));
 
   // proxy falls back
   bypass_stats->OnProxyFallback(fallback_proxy_server,
                                 net::ERR_PROXY_CONNECTION_FAILED);
   RunUntilIdle();
   EXPECT_TRUE(IsUnreachable());
 
   // proxy succeeds
-  bypass_stats->OnUrlRequestCompleted(url_request(), false);
+  bypass_stats->OnUrlRequestCompleted(url_request(), false, net::OK);
   RunUntilIdle();
   EXPECT_FALSE(IsUnreachable());
 }
 
 TEST_F(DataReductionProxyBypassStatsTest, ProxyReachableThenUnreachable) {
   net::ProxyServer fallback_proxy_server =
       net::ProxyServer::FromURI("foo.com", net::ProxyServer::SCHEME_HTTP);
   std::unique_ptr<DataReductionProxyBypassStats> bypass_stats =
       BuildBypassStats();
   EXPECT_CALL(*config(), WasDataReductionProxyUsed(url_request(), testing::_))
       .WillOnce(testing::Return(true));
   EXPECT_CALL(*config(), IsDataReductionProxy(testing::_, testing::_))
       .WillRepeatedly(testing::Return(true));
 
   // Proxy succeeds.
-  bypass_stats->OnUrlRequestCompleted(url_request(), false);
+  bypass_stats->OnUrlRequestCompleted(url_request(), false, net::OK);
   RunUntilIdle();
   EXPECT_FALSE(IsUnreachable());
 
   // Then proxy falls back indefinitely.
   bypass_stats->OnProxyFallback(fallback_proxy_server,
                                 net::ERR_PROXY_CONNECTION_FAILED);
   bypass_stats->OnProxyFallback(fallback_proxy_server,
                                 net::ERR_PROXY_CONNECTION_FAILED);
   bypass_stats->OnProxyFallback(fallback_proxy_server,
                                 net::ERR_PROXY_CONNECTION_FAILED);
@@ skipping 259 matching lines @@
     if (test.net_error != net::OK)
       fake_request->CancelWithError(static_cast<int>(test.net_error));
 
     DataReductionProxyTypeInfo proxy_info;
     proxy_info.proxy_index = test.proxy_index;
     EXPECT_CALL(*config(), WasDataReductionProxyUsed(fake_request.get(),
                                                      testing::NotNull()))
         .WillRepeatedly(testing::DoAll(testing::SetArgPointee<1>(proxy_info),
                                        Return(test.was_proxy_used)));
 
-    bypass_stats->OnUrlRequestCompleted(fake_request.get(), false);
+    bypass_stats->OnUrlRequestCompleted(fake_request.get(), false,
+                                        test.net_error);
 
     if (test.was_proxy_used && !test.is_load_bypass_proxy &&
         test.net_error == net::OK) {
       histogram_tester.ExpectUniqueSample(kPrimaryHistogramName,
                                           test.proxy_index, 1);
     } else {
       histogram_tester.ExpectTotalCount(kPrimaryHistogramName, 0);
     }
 
     if (test.was_proxy_used && !test.is_load_bypass_proxy &&
@@ skipping 450 matching lines @@
                               kNextBody.c_str(), nullptr, nullptr);
       histogram_tester.ExpectUniqueSample(
           "DataReductionProxy.BypassedBytes.NotBypassed", kNextBody.size(), 1);
       ExpectOtherBypassedBytesHistogramsEmpty(
           histogram_tester, "DataReductionProxy.BypassedBytes.NotBypassed");
     }
   }
 }
 
 }  // namespace data_reduction_proxy