Convert URLFetcher::Delegates to use an interface in content/public/common. Also remove the old U...

chrome/browser/policy/device_management_service_unittest.cc

 // Copyright (c) 2011 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 <ostream>
 #include <vector>
 
 #include "base/message_loop.h"
 #include "base/string_split.h"
 #include "chrome/browser/policy/device_management_backend_impl.h"
@@ skipping 103 matching lines @@
 
 TEST_P(DeviceManagementServiceFailedRequestTest, RegisterRequest) {
   DeviceRegisterResponseDelegateMock mock;
   EXPECT_CALL(mock, OnError(GetParam().expected_error_));
   em::DeviceRegisterRequest request;
   backend_->ProcessRegisterRequest(kGaiaAuthToken, kOAuthToken,
                                    kDeviceId, request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
-  fetcher->delegate()->OnURLFetchComplete(fetcher,
-                                          GURL(kServiceUrl),
-                                          GetParam().request_status_,
-                                          GetParam().http_status_,
-                                          net::ResponseCookies(),
-                                          GetParam().response_);
+  fetcher->set_url(GURL(kServiceUrl));
+  fetcher->set_status(GetParam().request_status_);
+  fetcher->set_response_code(GetParam().http_status_);
+  fetcher->SetResponseString(GetParam().response_);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 TEST_P(DeviceManagementServiceFailedRequestTest, UnregisterRequest) {
   DeviceUnregisterResponseDelegateMock mock;
   EXPECT_CALL(mock, OnError(GetParam().expected_error_));
   em::DeviceUnregisterRequest request;
   backend_->ProcessUnregisterRequest(kDMToken, kDeviceId, request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
-  fetcher->delegate()->OnURLFetchComplete(fetcher,
-                                          GURL(kServiceUrl),
-                                          GetParam().request_status_,
-                                          GetParam().http_status_,
-                                          net::ResponseCookies(),
-                                          GetParam().response_);
+  fetcher->set_url(GURL(kServiceUrl));
+  fetcher->set_status(GetParam().request_status_);
+  fetcher->set_response_code(GetParam().http_status_);
+  fetcher->SetResponseString(GetParam().response_);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 TEST_P(DeviceManagementServiceFailedRequestTest, PolicyRequest) {
   DevicePolicyResponseDelegateMock mock;
   EXPECT_CALL(mock, OnError(GetParam().expected_error_));
   em::DevicePolicyRequest request;
   request.set_policy_scope(kChromePolicyScope);
   em::DevicePolicySettingRequest* setting_request =
       request.add_setting_request();
   setting_request->set_key(kChromeDevicePolicySettingKey);
   backend_->ProcessPolicyRequest(kDMToken, kDeviceId,
                                  CloudPolicyDataStore::USER_AFFILIATION_NONE,
                                  request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
-  fetcher->delegate()->OnURLFetchComplete(fetcher,
-                                          GURL(kServiceUrl),
-                                          GetParam().request_status_,
-                                          GetParam().http_status_,
-                                          net::ResponseCookies(),
-                                          GetParam().response_);
+  fetcher->set_url(GURL(kServiceUrl));
+  fetcher->set_status(GetParam().request_status_);
+  fetcher->set_response_code(GetParam().http_status_);
+  fetcher->SetResponseString(GetParam().response_);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 INSTANTIATE_TEST_CASE_P(
     DeviceManagementServiceFailedRequestTestInstance,
     DeviceManagementServiceFailedRequestTest,
     testing::Values(
         FailedRequestParams(
             DeviceManagementBackend::kErrorRequestFailed,
             net::URLRequestStatus::FAILED,
             200,
@@ skipping 164 matching lines @@
   ASSERT_TRUE(expected_request_wrapper.SerializeToString(
       &expected_request_data));
   EXPECT_EQ(expected_request_data, fetcher->upload_data());
 
   // Generate the response.
   std::string response_data;
   em::DeviceManagementResponse response_wrapper;
   response_wrapper.mutable_register_response()->CopyFrom(expected_response);
   ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  fetcher->delegate()->OnURLFetchComplete(fetcher,
-                                          GURL(kServiceUrl),
-                                          status,
-                                          200,
-                                          net::ResponseCookies(),
-                                          response_data);
+  fetcher->set_url(GURL(kServiceUrl));
+  fetcher->set_status(status);
+  fetcher->set_response_code(200);
+  fetcher->SetResponseString(response_data);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 TEST_F(DeviceManagementServiceTest, UnregisterRequest) {
   DeviceUnregisterResponseDelegateMock mock;
   em::DeviceUnregisterResponse expected_response;
   EXPECT_CALL(mock, HandleUnregisterResponse(MessageEquals(expected_response)));
   em::DeviceUnregisterRequest request;
   backend_->ProcessUnregisterRequest(kDMToken, kDeviceId, request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
@@ skipping 16 matching lines @@
   ASSERT_TRUE(expected_request_wrapper.SerializeToString(
       &expected_request_data));
   EXPECT_EQ(expected_request_data, fetcher->upload_data());
 
   // Generate the response.
   std::string response_data;
   em::DeviceManagementResponse response_wrapper;
   response_wrapper.mutable_unregister_response()->CopyFrom(expected_response);
   ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  fetcher->delegate()->OnURLFetchComplete(fetcher,
-                                          GURL(kServiceUrl),
-                                          status,
-                                          200,
-                                          net::ResponseCookies(),
-                                          response_data);
+  fetcher->set_url(GURL(kServiceUrl));
+  fetcher->set_status(status);
+  fetcher->set_response_code(200);
+  fetcher->SetResponseString(response_data);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 TEST_F(DeviceManagementServiceTest, CancelRegisterRequest) {
   DeviceRegisterResponseDelegateMock mock;
   EXPECT_CALL(mock, HandleRegisterResponse(_)).Times(0);
   em::DeviceRegisterRequest request;
   backend_->ProcessRegisterRequest(kGaiaAuthToken, kOAuthToken,
                                    kDeviceId, request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
@@ skipping 53 matching lines @@
   fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   factory_.RemoveFetcherFromMap(0);
 
   // Check that the request is processed as expected.
   std::string response_data;
   em::DeviceManagementResponse response_wrapper;
   response_wrapper.mutable_register_response()->CopyFrom(expected_response);
   ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  fetcher->delegate()->OnURLFetchComplete(fetcher,
-                                          GURL(kServiceUrl),
-                                          status,
-                                          200,
-                                          net::ResponseCookies(),
-                                          response_data);
+  fetcher->set_url(GURL(kServiceUrl));
+  fetcher->set_status(status);
+  fetcher->set_response_code(200);
+  fetcher->SetResponseString(response_data);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
 }
 
 TEST_F(DeviceManagementServiceTest, CancelRequestAfterShutdown) {
   DevicePolicyResponseDelegateMock mock;
   EXPECT_CALL(mock, HandlePolicyResponse(_)).Times(0);
   em::DevicePolicyRequest request;
   request.set_policy_scope(kChromePolicyScope);
   em::DevicePolicySettingRequest* setting_request =
       request.add_setting_request();
   setting_request->set_key(kChromeDevicePolicySettingKey);
@@ skipping 17 matching lines @@
                                   &DeviceManagementServiceTest::ResetBackend))
       .RetiresOnSaturation();
   em::DeviceRegisterRequest request;
   backend_->ProcessRegisterRequest(kGaiaAuthToken, kOAuthToken,
                                    kDeviceId, request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
 
   // Generate a callback.
   net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  fetcher->delegate()->OnURLFetchComplete(fetcher,
-                                          GURL(kServiceUrl),
-                                          status,
-                                          500,
-                                          net::ResponseCookies(),
-                                          "");
+  fetcher->set_url(GURL(kServiceUrl));
+  fetcher->set_status(status);
+  fetcher->set_response_code(500);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
 
   // Backend should have been reset.
   EXPECT_FALSE(backend_.get());
 }
 
 TEST_F(DeviceManagementServiceTest, RetryOnProxyError) {
   // Make a request.
   DeviceRegisterResponseDelegateMock mock;
   EXPECT_CALL(mock, HandleRegisterResponse(_)).Times(0);
   EXPECT_CALL(mock, OnError(_)).Times(0);
 
   em::DeviceRegisterRequest request;
   backend_->ProcessRegisterRequest(kGaiaAuthToken, kOAuthToken,
                                    kDeviceId, request, &mock);
   TestURLFetcher* fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_TRUE((fetcher->load_flags() & net::LOAD_BYPASS_PROXY) == 0);
   const GURL original_url(fetcher->original_url());
   const std::string upload_data(fetcher->upload_data());
 
   // Generate a callback with a proxy failure.
   net::URLRequestStatus status(net::URLRequestStatus::FAILED,
                                net::ERR_PROXY_CONNECTION_FAILED);
-  fetcher->delegate()->OnURLFetchComplete(fetcher,
-                                          GURL(kServiceUrl),
-                                          status,
-                                          0,
-                                          net::ResponseCookies(),
-                                          "");
+  fetcher->set_url(GURL(kServiceUrl));
+  fetcher->set_status(status);
+  fetcher->set_response_code(200);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
 
   // Verify that a new URLFetcher was started that bypasses the proxy.
   fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_TRUE(fetcher->load_flags() & net::LOAD_BYPASS_PROXY);
   EXPECT_EQ(original_url, fetcher->original_url());
   EXPECT_EQ(upload_data, fetcher->upload_data());
 }
 
 TEST_F(DeviceManagementServiceTest, RetryOnBadResponseFromProxy) {
@@ skipping 12 matching lines @@
   const std::string upload_data(fetcher->upload_data());
   fetcher->set_was_fetched_via_proxy(true);
   scoped_refptr<net::HttpResponseHeaders> headers;
   headers = new net::HttpResponseHeaders(
       "HTTP/1.1 200 OK\0Content-type: bad/type\0\0");
   fetcher->set_response_headers(headers);
 
   // Generate a callback with a valid http response, that was generated by
   // a bad/wrong proxy.
   net::URLRequestStatus status;
-  fetcher->delegate()->OnURLFetchComplete(fetcher,
-                                          GURL(kServiceUrl),
-                                          status,
-                                          200,
-                                          net::ResponseCookies(),
-                                          "");
+  fetcher->set_url(GURL(kServiceUrl));
+  fetcher->set_status(status);
+  fetcher->set_response_code(200);
+  fetcher->delegate()->OnURLFetchComplete(fetcher);
 
   // Verify that a new URLFetcher was started that bypasses the proxy.
   fetcher = factory_.GetFetcherByID(0);
   ASSERT_TRUE(fetcher);
   EXPECT_TRUE((fetcher->load_flags() & net::LOAD_BYPASS_PROXY) != 0);
   EXPECT_EQ(original_url, fetcher->original_url());
   EXPECT_EQ(upload_data, fetcher->upload_data());
 }
 
 }  // namespace policy