net: Remove typedef net::URLRequestStatus URLRequestStatus;

net/url_request/url_request_job_tracker_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 <string.h>
 #include <algorithm>
 #include <string>
 #include <vector>
 #include "base/message_loop.h"
 #include "googleurl/src/gurl.h"
@@ skipping 36 matching lines @@
   }
 
   return true;
 }
 
 class MockJobObserver : public net::URLRequestJobTracker::JobObserver {
  public:
   MOCK_METHOD1(OnJobAdded, void(net::URLRequestJob* job));
   MOCK_METHOD1(OnJobRemoved, void(net::URLRequestJob* job));
   MOCK_METHOD2(OnJobDone, void(net::URLRequestJob* job,
-                               const URLRequestStatus& status));
+                               const net::URLRequestStatus& status));
   MOCK_METHOD3(OnJobRedirect, void(net::URLRequestJob* job,
                                    const GURL& location,
                                    int status_code));
   MOCK_METHOD3(OnBytesRead, void(net::URLRequestJob* job,
                                  const char* buf,
                                  int byte_count));
 };
 
 // A net::URLRequestJob that returns static content for given URLs. We do
 // not use net::URLRequestTestJob here because net::URLRequestTestJob fakes
@@ skipping 19 matching lines @@
     const size_t bytes_to_read = std::min(
         response_data_.size(), static_cast<size_t>(buf_size));
 
     // Regardless of whether we're performing a sync or async read,
     // copy the data into the caller's buffer now. That way we don't
     // have to hold on to the buffers in the async case.
     memcpy(buf->data(), response_data_.data(), bytes_to_read);
     response_data_.erase(0, bytes_to_read);
 
     if (async_reads_) {
-      SetStatus(URLRequestStatus(URLRequestStatus::IO_PENDING, 0));
+      SetStatus(net::URLRequestStatus(net::URLRequestStatus::IO_PENDING, 0));
       MessageLoop::current()->PostTask(FROM_HERE, NewRunnableMethod(
           this, &URLRequestJobTrackerTestJob::OnReadCompleted,
           bytes_to_read));
     } else {
-      SetStatus(URLRequestStatus());
+      SetStatus(net::URLRequestStatus());
       *bytes_read = bytes_to_read;
     }
     return !async_reads_;
   }
 
   void OnReadCompleted(int status) {
     if (status == 0) {
-      NotifyDone(URLRequestStatus());
+      NotifyDone(net::URLRequestStatus());
     } else if (status > 0) {
-      SetStatus(URLRequestStatus());
+      SetStatus(net::URLRequestStatus());
     } else {
       ASSERT_FALSE(true) << "Unexpected OnReadCompleted callback.";
     }
 
     NotifyReadComplete(status);
   }
 
   bool GetContentEncodings(
       std::vector<Filter::FilterType>* encoding_types) {
     if (request_->url().spec() == "test:basic") {
       return false;
     } else if (request_->url().spec() == "test:compressed") {
       encoding_types->push_back(Filter::FILTER_TYPE_GZIP);
       return true;
     } else {
       return net::URLRequestJob::GetContentEncodings(encoding_types);
     }
   }
 
   // The data to send, will be set in Start().
   std::string response_data_;
 
   // Should reads be synchronous or asynchronous?
   const bool async_reads_;
 };
 
-// Google Mock Matcher to check two URLRequestStatus instances for
+// Google Mock Matcher to check two net::URLRequestStatus instances for
 // equality.
 MATCHER_P(StatusEq, other, "") {
   return (arg.status() == other.status() &&
           arg.os_error() == other.os_error());
 }
 
 // Google Mock Matcher to check that two blocks of memory are equal.
 MATCHER_P2(MemEq, other, len, "") {
   return memcmp(arg, other, len) == 0;
 }
@@ skipping 15 matching lines @@
     const GURL gurl(url);
     std::string body;
     ASSERT_TRUE(GetResponseBody(gurl, &body));
 
     // We expect to receive one call for each method on the JobObserver,
     // in the following order:
     EXPECT_CALL(observer, OnJobAdded(NotNull()));
     EXPECT_CALL(observer, OnBytesRead(NotNull(),
                                       MemEq(body.data(), body.size()),
                                       Eq(static_cast<int>(body.size()))));
-    EXPECT_CALL(observer, OnJobDone(NotNull(), StatusEq(URLRequestStatus())));
+    EXPECT_CALL(observer, OnJobDone(NotNull(),
+                StatusEq(net::URLRequestStatus())));
     EXPECT_CALL(observer, OnJobRemoved(NotNull()));
 
     // Attach our observer and perform the resource fetch.
     net::g_url_request_job_tracker.AddObserver(&observer);
     Fetch(gurl);
     net::g_url_request_job_tracker.RemoveObserver(&observer);
   }
 
   void Fetch(const GURL& url) {
     TestDelegate d;
@@ skipping 38 matching lines @@
   g_async_reads = true;
   AssertJobTrackerCallbacks("test:compressed");
 }
 
 TEST_F(URLRequestJobTrackerTest, CompressedSync) {
   g_async_reads = false;
   AssertJobTrackerCallbacks("test:compressed");
 }
 
 }  // namespace