Fix all failed and canceled URLRequestStatuses without errors.

components/policy/core/common/cloud/device_management_service_unittest.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.
 
 #include <ostream>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/run_loop.h"
 #include "base/strings/string_split.h"
@@ skipping 132 matching lines @@
     request->set_modulus(1);
     request->set_remainder(0);
     job->SetRetryCallback(base::Bind(
         &DeviceManagementServiceTestBase::OnJobRetry, base::Unretained(this)));
     job->Start(base::Bind(&DeviceManagementServiceTestBase::OnJobDone,
                           base::Unretained(this)));
     return job;
   }
 
   void SendResponse(net::TestURLFetcher* fetcher,
-                    const net::URLRequestStatus request_status,
+                    net::Error error,
                     int http_status,
                     const std::string& response) {
     fetcher->set_url(GURL(kServiceUrl));
-    fetcher->set_status(request_status);
+    fetcher->set_status(net::URLRequestStatus::FromError(error));
     fetcher->set_response_code(http_status);
     fetcher->SetResponseString(response);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
   }
 
   MOCK_METHOD3(OnJobDone, void(DeviceManagementStatus, int,
                                const em::DeviceManagementResponse&));
 
   MOCK_METHOD1(OnJobRetry, void(DeviceManagementRequestJob*));
 
   base::MessageLoop loop_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_;
   net::TestURLFetcherFactory factory_;
   scoped_ptr<DeviceManagementService> service_;
 };
 
 struct FailedRequestParams {
   FailedRequestParams(DeviceManagementStatus expected_status,
-                      net::URLRequestStatus::Status request_status,
+                      net::Error error,
                       int http_status,
                       const std::string& response)
       : expected_status_(expected_status),
-        request_status_(request_status, 0),
+        error_(error),
         http_status_(http_status),
         response_(response) {}
 
   DeviceManagementStatus expected_status_;
-  net::URLRequestStatus request_status_;
+  net::Error error_;
   int http_status_;
   std::string response_;
 };
 
 void PrintTo(const FailedRequestParams& params, std::ostream* os) {
   *os << "FailedRequestParams " << params.expected_status_
-      << " " << params.request_status_.status()
+      << " " << params.error_
       << " " << params.http_status_;
 }
 
 // A parameterized test case for erroneous response situations, they're mostly
 // the same for all kinds of requests.
 class DeviceManagementServiceFailedRequestTest
     : public DeviceManagementServiceTestBase,
       public testing::WithParamInterface<FailedRequestParams> {
 };
 
 TEST_P(DeviceManagementServiceFailedRequestTest, RegisterRequest) {
   EXPECT_CALL(*this, OnJobDone(GetParam().expected_status_, _, _));
   EXPECT_CALL(*this, OnJobRetry(_)).Times(0);
   scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
 
-  SendResponse(fetcher, GetParam().request_status_, GetParam().http_status_,
+  SendResponse(fetcher, GetParam().error_, GetParam().http_status_,
                GetParam().response_);
 }
 
 TEST_P(DeviceManagementServiceFailedRequestTest, ApiAuthCodeFetchRequest) {
   EXPECT_CALL(*this, OnJobDone(GetParam().expected_status_, _, _));
   EXPECT_CALL(*this, OnJobRetry(_)).Times(0);
   scoped_ptr<DeviceManagementRequestJob> request_job(
       StartApiAuthCodeFetchJob());
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
 
-  SendResponse(fetcher, GetParam().request_status_, GetParam().http_status_,
+  SendResponse(fetcher, GetParam().error_, GetParam().http_status_,
                GetParam().response_);
 }
 
 TEST_P(DeviceManagementServiceFailedRequestTest, UnregisterRequest) {
   EXPECT_CALL(*this, OnJobDone(GetParam().expected_status_, _, _));
   EXPECT_CALL(*this, OnJobRetry(_)).Times(0);
   scoped_ptr<DeviceManagementRequestJob> request_job(StartUnregistrationJob());
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
 
-  SendResponse(fetcher, GetParam().request_status_, GetParam().http_status_,
+  SendResponse(fetcher, GetParam().error_, GetParam().http_status_,
                GetParam().response_);
 }
 
 TEST_P(DeviceManagementServiceFailedRequestTest, PolicyRequest) {
   EXPECT_CALL(*this, OnJobDone(GetParam().expected_status_, _, _));
   EXPECT_CALL(*this, OnJobRetry(_)).Times(0);
   scoped_ptr<DeviceManagementRequestJob> request_job(StartPolicyFetchJob());
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
 
-  SendResponse(fetcher, GetParam().request_status_, GetParam().http_status_,
+  SendResponse(fetcher, GetParam().error_, GetParam().http_status_,
                GetParam().response_);
 }
 
 TEST_P(DeviceManagementServiceFailedRequestTest, AutoEnrollmentRequest) {
   EXPECT_CALL(*this, OnJobDone(GetParam().expected_status_, _, _));
   EXPECT_CALL(*this, OnJobRetry(_)).Times(0);
   scoped_ptr<DeviceManagementRequestJob> request_job(StartAutoEnrollmentJob());
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
 
-  SendResponse(fetcher, GetParam().request_status_, GetParam().http_status_,
+  SendResponse(fetcher, GetParam().error_, GetParam().http_status_,
                GetParam().response_);
 }
 
 INSTANTIATE_TEST_CASE_P(
     DeviceManagementServiceFailedRequestTestInstance,
     DeviceManagementServiceFailedRequestTest,
     testing::Values(
         FailedRequestParams(
             DM_STATUS_REQUEST_FAILED,
-            net::URLRequestStatus::FAILED,
+            net::ERR_FAILED,
             200,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DM_STATUS_HTTP_STATUS_ERROR,
-            net::URLRequestStatus::SUCCESS,
+            net::OK,
             666,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DM_STATUS_RESPONSE_DECODING_ERROR,
-            net::URLRequestStatus::SUCCESS,
+            net::OK,
             200,
             PROTO_STRING("Not a protobuf.")),
         FailedRequestParams(
             DM_STATUS_SERVICE_MANAGEMENT_NOT_SUPPORTED,
-            net::URLRequestStatus::SUCCESS,
+            net::OK,
             403,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DM_STATUS_SERVICE_INVALID_SERIAL_NUMBER,
-            net::URLRequestStatus::SUCCESS,
+            net::OK,
             405,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DM_STATUS_SERVICE_DEVICE_ID_CONFLICT,
-            net::URLRequestStatus::SUCCESS,
+            net::OK,
             409,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DM_STATUS_SERVICE_DEVICE_NOT_FOUND,
-            net::URLRequestStatus::SUCCESS,
+            net::OK,
             410,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DM_STATUS_SERVICE_MANAGEMENT_TOKEN_INVALID,
-            net::URLRequestStatus::SUCCESS,
+            net::OK,
             401,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DM_STATUS_REQUEST_INVALID,
-            net::URLRequestStatus::SUCCESS,
+            net::OK,
             400,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DM_STATUS_TEMPORARY_UNAVAILABLE,
-            net::URLRequestStatus::SUCCESS,
+            net::OK,
             404,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DM_STATUS_SERVICE_ACTIVATION_PENDING,
-            net::URLRequestStatus::SUCCESS,
+            net::OK,
             412,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DM_STATUS_SERVICE_MISSING_LICENSES,
-            net::URLRequestStatus::SUCCESS,
+            net::OK,
             402,
             PROTO_STRING(kResponseEmpty))));
 
 // Simple query parameter parser for testing.
 class QueryParams {
  public:
   explicit QueryParams(const std::string& query) {
     base::SplitStringIntoKeyValuePairs(query, '=', '&', &params_);
   }
 
@@ skipping 75 matching lines @@
                          dm_protocol::kValueRequestRegister,
                          kClientID);
 
   std::string expected_data;
   ASSERT_TRUE(request_job->GetRequest()->SerializeToString(&expected_data));
   EXPECT_EQ(expected_data, fetcher->upload_data());
 
   // Generate the response.
   std::string response_data;
   ASSERT_TRUE(expected_response.SerializeToString(&response_data));
-  net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  SendResponse(fetcher, status, 200, response_data);
+  SendResponse(fetcher, net::OK, 200, response_data);
 }
 
 TEST_F(DeviceManagementServiceTest, ApiAuthCodeFetchRequest) {
   em::DeviceManagementResponse expected_response;
   expected_response.mutable_service_api_access_response()->set_auth_code(
       kRobotAuthCode);
   EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _,
                                MessageEquals(expected_response)));
   EXPECT_CALL(*this, OnJobRetry(_)).Times(0);
   scoped_ptr<DeviceManagementRequestJob> request_job(
       StartApiAuthCodeFetchJob());
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
 
   CheckURLAndQueryParams(fetcher->GetOriginalURL(),
                          dm_protocol::kValueRequestApiAuthorization,
                          kClientID);
 
   std::string expected_data;
   ASSERT_TRUE(request_job->GetRequest()->SerializeToString(&expected_data));
   EXPECT_EQ(expected_data, fetcher->upload_data());
 
   // Generate the response.
   std::string response_data;
   ASSERT_TRUE(expected_response.SerializeToString(&response_data));
-  net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  SendResponse(fetcher, status, 200, response_data);
+  SendResponse(fetcher, net::OK, 200, response_data);
 }
 
 TEST_F(DeviceManagementServiceTest, UnregisterRequest) {
   em::DeviceManagementResponse expected_response;
   expected_response.mutable_unregister_response();
   EXPECT_CALL(*this, OnJobDone(DM_STATUS_SUCCESS, _,
                                MessageEquals(expected_response)));
   EXPECT_CALL(*this, OnJobRetry(_)).Times(0);
   scoped_ptr<DeviceManagementRequestJob> request_job(StartUnregistrationJob());
   net::TestURLFetcher* fetcher = GetFetcher();
@@ skipping 11 matching lines @@
                          dm_protocol::kValueRequestUnregister,
                          kClientID);
 
   std::string expected_data;
   ASSERT_TRUE(request_job->GetRequest()->SerializeToString(&expected_data));
   EXPECT_EQ(expected_data, fetcher->upload_data());
 
   // Generate the response.
   std::string response_data;
   ASSERT_TRUE(expected_response.SerializeToString(&response_data));
-  net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  SendResponse(fetcher, status, 200, response_data);
+  SendResponse(fetcher, net::OK, 200, response_data);
 }
 
 TEST_F(DeviceManagementServiceTest, CancelRegisterRequest) {
   EXPECT_CALL(*this, OnJobDone(_, _, _)).Times(0);
   EXPECT_CALL(*this, OnJobRetry(_)).Times(0);
   scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
 
   // There shouldn't be any callbacks.
@@ skipping 52 matching lines @@
 
   // Now initialize the service. That should start the job.
   InitializeService();
   fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
   factory_.RemoveFetcherFromMap(DeviceManagementService::kURLFetcherID);
 
   // Check that the request is processed as expected.
   std::string response_data;
   ASSERT_TRUE(expected_response.SerializeToString(&response_data));
-  net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  SendResponse(fetcher, status, 200, response_data);
+  SendResponse(fetcher, net::OK, 200, response_data);
 }
 
 TEST_F(DeviceManagementServiceTest, CancelRequestAfterShutdown) {
   EXPECT_CALL(*this, OnJobDone(_, _, _)).Times(0);
   EXPECT_CALL(*this, OnJobRetry(_)).Times(0);
   scoped_ptr<DeviceManagementRequestJob> request_job(StartPolicyFetchJob());
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
 
   // Shutdown the service and cancel the job afterwards.
   service_->Shutdown();
   request_job.reset();
 }
 
 ACTION_P(ResetPointer, pointer) {
   pointer->reset();
 }
 
 TEST_F(DeviceManagementServiceTest, CancelDuringCallback) {
   // Make a request.
   scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
 
   EXPECT_CALL(*this, OnJobDone(_, _, _))
       .WillOnce(ResetPointer(&request_job));
   EXPECT_CALL(*this, OnJobRetry(_)).Times(0);
 
   // Generate a callback.
-  net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
-  SendResponse(fetcher, status, 500, std::string());
+  SendResponse(fetcher, net::OK, 500, std::string());
 
   // Job should have been reset.
   EXPECT_FALSE(request_job.get());
 }
 
 TEST_F(DeviceManagementServiceTest, RetryOnProxyError) {
   // Make a request.
   EXPECT_CALL(*this, OnJobDone(_, _, _)).Times(0);
   EXPECT_CALL(*this, OnJobRetry(_));
 
   scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(0, fetcher->GetLoadFlags() & net::LOAD_BYPASS_PROXY);
   const GURL original_url(fetcher->GetOriginalURL());
   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);
-  SendResponse(fetcher, status, 200, std::string());
+  SendResponse(fetcher, net::ERR_PROXY_CONNECTION_FAILED, 200, std::string());
 
   // Verify that a new URLFetcher was started that bypasses the proxy.
   fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
   EXPECT_TRUE(fetcher->GetLoadFlags() & net::LOAD_BYPASS_PROXY);
   EXPECT_EQ(original_url, fetcher->GetOriginalURL());
   EXPECT_EQ(upload_data, fetcher->upload_data());
 }
 
 TEST_F(DeviceManagementServiceTest, RetryOnBadResponseFromProxy) {
   // Make a request.
   EXPECT_CALL(*this, OnJobDone(_, _, _)).Times(0);
   EXPECT_CALL(*this, OnJobRetry(_));
 
   scoped_ptr<DeviceManagementRequestJob> request_job(StartRegistrationJob());
   net::TestURLFetcher* fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
   EXPECT_EQ(0, fetcher->GetLoadFlags() & net::LOAD_BYPASS_PROXY);
   const GURL original_url(fetcher->GetOriginalURL());
   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;
-  SendResponse(fetcher, status, 200, std::string());
+  SendResponse(fetcher, net::OK, 200, std::string());
 
   // Verify that a new URLFetcher was started that bypasses the proxy.
   fetcher = GetFetcher();
   ASSERT_TRUE(fetcher);
   EXPECT_NE(0, fetcher->GetLoadFlags() & net::LOAD_BYPASS_PROXY);
   EXPECT_EQ(original_url, fetcher->GetOriginalURL());
   EXPECT_EQ(upload_data, fetcher->upload_data());
 }
 
 TEST_F(DeviceManagementServiceTest, RetryOnNetworkChanges) {
@@ skipping 47 matching lines @@
   EXPECT_CALL(*this, OnJobDone(DM_STATUS_REQUEST_FAILED, _, _));
   EXPECT_CALL(*this, OnJobRetry(_)).Times(0);
   fetcher->set_status(net::URLRequestStatus(net::URLRequestStatus::FAILED,
                                             net::ERR_NETWORK_CHANGED));
   fetcher->set_url(GURL(kServiceUrl));
   fetcher->delegate()->OnURLFetchComplete(fetcher);
   Mock::VerifyAndClearExpectations(this);
 }
 
 }  // namespace policy