net: Remove typedef net::URLRequestStatus URLRequestStatus;

chrome/browser/policy/device_management_service_unittest.cc

-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
+// 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 <vector>
 
 #include "base/message_loop.h"
 #include "base/string_split.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/policy/device_management_backend_impl.h"
 #include "chrome/browser/policy/device_management_backend_mock.h"
@@ skipping 63 matching lines @@
   scoped_ptr<DeviceManagementService> service_;
   scoped_ptr<DeviceManagementBackend> backend_;
 
  private:
   MessageLoopForUI loop_;
   BrowserThread io_thread_;
 };
 
 struct FailedRequestParams {
   FailedRequestParams(DeviceManagementBackend::ErrorCode expected_error,
-                      URLRequestStatus::Status request_status,
+                      net::URLRequestStatus::Status request_status,
                       int http_status,
                       const std::string& response)
       : expected_error_(expected_error),
         request_status_(request_status, 0),
         http_status_(http_status),
         response_(response) {}
 
   DeviceManagementBackend::ErrorCode expected_error_;
-  URLRequestStatus request_status_;
+  net::URLRequestStatus request_status_;
   int http_status_;
   std::string response_;
 };
 
 // A parameterized test case for erroneous response situations, they're mostly
 // the same for all kinds of requests.
 class DeviceManagementServiceFailedRequestTest
     : public DeviceManagementServiceTestBase<
           testing::TestWithParam<FailedRequestParams> > {
 };
@@ skipping 49 matching lines @@
                                           ResponseCookies(),
                                           GetParam().response_);
 }
 
 INSTANTIATE_TEST_CASE_P(
     DeviceManagementServiceFailedRequestTestInstance,
     DeviceManagementServiceFailedRequestTest,
     testing::Values(
         FailedRequestParams(
             DeviceManagementBackend::kErrorRequestFailed,
-            URLRequestStatus::FAILED,
+            net::URLRequestStatus::FAILED,
             200,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DeviceManagementBackend::kErrorHttpStatus,
-            URLRequestStatus::SUCCESS,
+            net::URLRequestStatus::SUCCESS,
             500,
             PROTO_STRING(kResponseEmpty)),
         FailedRequestParams(
             DeviceManagementBackend::kErrorResponseDecoding,
-            URLRequestStatus::SUCCESS,
+            net::URLRequestStatus::SUCCESS,
             200,
             PROTO_STRING("Not a protobuf.")),
         FailedRequestParams(
             DeviceManagementBackend::kErrorServiceManagementNotSupported,
-            URLRequestStatus::SUCCESS,
+            net::URLRequestStatus::SUCCESS,
             200,
             PROTO_STRING(kResponseErrorManagementNotSupported)),
         FailedRequestParams(
             DeviceManagementBackend::kErrorServiceDeviceNotFound,
-            URLRequestStatus::SUCCESS,
+            net::URLRequestStatus::SUCCESS,
             200,
             PROTO_STRING(kResponseErrorDeviceNotFound)),
         FailedRequestParams(
             DeviceManagementBackend::kErrorServiceManagementTokenInvalid,
-            URLRequestStatus::SUCCESS,
+            net::URLRequestStatus::SUCCESS,
             200,
             PROTO_STRING(kResponseErrorManagementTokenInvalid)),
         FailedRequestParams(
             DeviceManagementBackend::kErrorServiceActivationPending,
-            URLRequestStatus::SUCCESS,
+            net::URLRequestStatus::SUCCESS,
             200,
             PROTO_STRING(kResponseErrorActivationPending))));
 
 // Simple query parameter parser for testing.
 class QueryParams {
  public:
   explicit QueryParams(const std::string& query) {
     base::SplitStringIntoKeyValuePairs(query, '=', '&', &params_);
   }
 
@@ skipping 87 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.set_error(em::DeviceManagementResponse::SUCCESS);
   response_wrapper.mutable_register_response()->CopyFrom(expected_response);
   ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
-  URLRequestStatus status(URLRequestStatus::SUCCESS, 0);
+  net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
   fetcher->delegate()->OnURLFetchComplete(fetcher,
                                           GURL(kServiceUrl),
                                           status,
                                           200,
                                           ResponseCookies(),
                                           response_data);
 }
 
 TEST_F(DeviceManagementServiceTest, UnregisterRequest) {
   DeviceUnregisterResponseDelegateMock mock;
@@ skipping 22 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.set_error(em::DeviceManagementResponse::SUCCESS);
   response_wrapper.mutable_unregister_response()->CopyFrom(expected_response);
   ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
-  URLRequestStatus status(URLRequestStatus::SUCCESS, 0);
+  net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
   fetcher->delegate()->OnURLFetchComplete(fetcher,
                                           GURL(kServiceUrl),
                                           status,
                                           200,
                                           ResponseCookies(),
                                           response_data);
 }
 
 TEST_F(DeviceManagementServiceTest, PolicyRequest) {
   DevicePolicyResponseDelegateMock mock;
@@ skipping 34 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.set_error(em::DeviceManagementResponse::SUCCESS);
   response_wrapper.mutable_policy_response()->CopyFrom(expected_response);
   ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
-  URLRequestStatus status(URLRequestStatus::SUCCESS, 0);
+  net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
   fetcher->delegate()->OnURLFetchComplete(fetcher,
                                           GURL(kServiceUrl),
                                           status,
                                           200,
                                           ResponseCookies(),
                                           response_data);
 }
 
 TEST_F(DeviceManagementServiceTest, CancelRegisterRequest) {
   DeviceRegisterResponseDelegateMock mock;
@@ skipping 55 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.set_error(em::DeviceManagementResponse::SUCCESS);
   response_wrapper.mutable_register_response()->CopyFrom(expected_response);
   ASSERT_TRUE(response_wrapper.SerializeToString(&response_data));
-  URLRequestStatus status(URLRequestStatus::SUCCESS, 0);
+  net::URLRequestStatus status(net::URLRequestStatus::SUCCESS, 0);
   fetcher->delegate()->OnURLFetchComplete(fetcher,
                                           GURL(kServiceUrl),
                                           status,
                                           200,
                                           ResponseCookies(),
                                           response_data);
 }
 
 }  // namespace policy