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

components/data_reduction_proxy/core/browser/data_reduction_proxy_interceptor_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_interceptor.h"
 
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 242 matching lines @@
   // Tests the mechanics of proxy bypass work with a "real" server. For tests
   // that cover every imaginable response that could trigger a bypass, see:
   // DataReductionProxyProtocolTest.
   net::TestDelegate delegate;
   std::unique_ptr<net::URLRequest> request(context().CreateRequest(
       direct().GetURL("/block10.html"), net::DEFAULT_PRIORITY, &delegate));
   request->Start();
   EXPECT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
-  EXPECT_EQ(net::OK, request->status().error());
+  EXPECT_EQ(net::OK, delegate.request_status());
   EXPECT_EQ("hello", delegate.data_received());
 }
 
 TEST_F(DataReductionProxyInterceptorWithServerTest, TestNoBypass) {
   net::TestDelegate delegate;
   std::unique_ptr<net::URLRequest> request(context().CreateRequest(
       direct().GetURL("/noblock.html"), net::DEFAULT_PRIORITY, &delegate));
   request->Start();
   EXPECT_TRUE(request->is_pending());
   base::RunLoop().Run();
 
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
-  EXPECT_EQ(net::OK, request->status().error());
+  EXPECT_EQ(net::OK, delegate.request_status());
   EXPECT_EQ("hello", delegate.data_received());
 }
 
 class DataReductionProxyInterceptorEndToEndTest : public testing::Test {
  public:
   DataReductionProxyInterceptorEndToEndTest()
       : context_(true), context_storage_(&context_) {}
 
   ~DataReductionProxyInterceptorEndToEndTest() override {}
 
@@ skipping 19 matching lines @@
   // Creates a URLRequest using the test's TestURLRequestContext and executes
   // it. Returns the created URLRequest.
   std::unique_ptr<net::URLRequest> CreateAndExecuteRequest(const GURL& url) {
     std::unique_ptr<net::URLRequest> request(
         context_.CreateRequest(url, net::IDLE, &delegate_));
     request->Start();
     drp_test_context_->RunUntilIdle();
     return request;
   }
 
-  const net::TestDelegate& delegate() const {
-    return delegate_;
-  }
+  const net::TestDelegate& delegate() const { return delegate_; }
 
   net::MockClientSocketFactory* mock_socket_factory() {
     return &mock_socket_factory_;
   }
 
   TestDataReductionProxyConfig* config() const {
     return drp_test_context_->config();
   }
 
   net::ProxyServer origin() const {
@@ skipping 19 matching lines @@
       MockRead(kBody.c_str()),
       MockRead(net::SYNCHRONOUS, net::OK),
   };
   net::StaticSocketDataProvider socket_data_provider(
       mock_reads, arraysize(mock_reads), nullptr, 0);
   mock_socket_factory()->AddSocketDataProvider(&socket_data_provider);
 
   std::unique_ptr<net::URLRequest> request =
       CreateAndExecuteRequest(GURL("http://foo.com"));
 
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+  EXPECT_EQ(net::OK, delegate().request_status());
   EXPECT_EQ(200, request->GetResponseCode());
   EXPECT_EQ(kBody, delegate().data_received());
   EXPECT_EQ(origin().host_port_pair().ToString(),
             request->proxy_server().ToString());
 }
 
 TEST_F(DataReductionProxyInterceptorEndToEndTest, RedirectWithoutRetry) {
   // The redirect comes through the proxy and should not be retried.
   MockRead redirect_mock_reads[] = {
       MockRead("HTTP/1.1 302 Found\r\n"
@@ skipping 13 matching lines @@
       MockRead(kBody.c_str()),
       MockRead(net::SYNCHRONOUS, net::OK),
   };
   net::StaticSocketDataProvider response_socket_data_provider(
       response_mock_reads, arraysize(response_mock_reads), nullptr, 0);
   mock_socket_factory()->AddSocketDataProvider(&response_socket_data_provider);
 
   std::unique_ptr<net::URLRequest> request =
       CreateAndExecuteRequest(GURL("http://foo.com"));
 
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+  EXPECT_EQ(net::OK, delegate().request_status());
   EXPECT_EQ(200, request->GetResponseCode());
   EXPECT_EQ(kBody, delegate().data_received());
   EXPECT_EQ(origin().host_port_pair().ToString(),
             request->proxy_server().ToString());
   // The redirect should have been processed and followed normally.
   EXPECT_EQ(1, delegate().received_redirect_count());
 }
 
 TEST_F(DataReductionProxyInterceptorEndToEndTest, ResponseWithBypassAndRetry) {
   // The first try gives a bypass.
@@ skipping 14 matching lines @@
       MockRead(kBody.c_str()),
       MockRead(net::SYNCHRONOUS, net::OK),
   };
   net::StaticSocketDataProvider retry_socket_data_provider(
       retry_mock_reads, arraysize(retry_mock_reads), nullptr, 0);
   mock_socket_factory()->AddSocketDataProvider(&retry_socket_data_provider);
 
   std::unique_ptr<net::URLRequest> request =
       CreateAndExecuteRequest(GURL("http://foo.com"));
 
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+  EXPECT_EQ(net::OK, delegate().request_status());
   EXPECT_EQ(200, request->GetResponseCode());
   EXPECT_EQ(kBody, delegate().data_received());
   EXPECT_FALSE(request->was_fetched_via_proxy());
   // The bypassed response should have been intercepted before the response was
   // processed, so only the final response after the retry should have been
   // processed.
   EXPECT_EQ(1, delegate().response_started_count());
 }
 
 TEST_F(DataReductionProxyInterceptorEndToEndTest, RedirectWithBypassAndRetry) {
@@ skipping 26 matching lines @@
     socket_data_providers.push_back(
         base::MakeUnique<net::StaticSocketDataProvider>(mock_reads, 3, nullptr,
                                                         0));
     mock_socket_factory()->AddSocketDataProvider(
         socket_data_providers.back().get());
   }
 
   std::unique_ptr<net::URLRequest> request =
       CreateAndExecuteRequest(GURL("http://foo.com"));
 
-  EXPECT_EQ(net::URLRequestStatus::SUCCESS, request->status().status());
+  EXPECT_EQ(net::OK, delegate().request_status());
   EXPECT_EQ(200, request->GetResponseCode());
   EXPECT_EQ(kBody, delegate().data_received());
   EXPECT_FALSE(request->was_fetched_via_proxy());
 
   // Each of the redirects should have been intercepted before being followed.
   EXPECT_EQ(0, delegate().received_redirect_count());
   EXPECT_EQ(std::vector<GURL>(1, GURL("http://foo.com")), request->url_chain());
 }
 
 TEST_F(DataReductionProxyInterceptorEndToEndTest, RedirectChainToHttps) {
@@ skipping 34 matching lines @@
   std::vector<GURL> expected_url_chain;
   expected_url_chain.push_back(GURL("http://music.google.com"));
   expected_url_chain.push_back(GURL("http://play.google.com"));
   expected_url_chain.push_back(GURL("https://play.google.com"));
   EXPECT_EQ(expected_url_chain, request->url_chain());
 }
 
 }  // namespace
 
 }  // namespace data_reduction_proxy