net: Remove typedef net::URLRequest URLRequest;

webkit/appcache/appcache_url_request_job_unittest.cc

 // Copyright (c) 2010 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 <stack>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/pickle.h"
 #include "base/thread.h"
@@ skipping 38 matching lines @@
       loaded_info_ = info;
       loaded_info_id_ = response_id;
       test_->ScheduleNextTask();
     }
 
     scoped_refptr<AppCacheResponseInfo> loaded_info_;
     int64 loaded_info_id_;
     AppCacheURLRequestJobTest* test_;
   };
 
-  class MockURLRequestDelegate : public URLRequest::Delegate {
+  class MockURLRequestDelegate : public net::URLRequest::Delegate {
    public:
     explicit MockURLRequestDelegate(AppCacheURLRequestJobTest* test)
         : test_(test),
           received_data_(new net::IOBuffer(kNumBlocks * kBlockSize)),
           did_receive_headers_(false), amount_received_(0),
           kill_after_amount_received_(0), kill_with_io_pending_(false) {
     }
 
-    virtual void OnResponseStarted(URLRequest* request) {
+    virtual void OnResponseStarted(net::URLRequest* request) {
       amount_received_ = 0;
       did_receive_headers_ = false;
       if (request->status().is_success()) {
         EXPECT_TRUE(request->response_headers());
         did_receive_headers_ = true;
         received_info_ = request->response_info();
         ReadSome(request);
       } else {
         RequestComplete();
       }
     }
 
-    virtual void OnReadCompleted(URLRequest* request, int bytes_read) {
+    virtual void OnReadCompleted(net::URLRequest* request, int bytes_read) {
       if (bytes_read > 0) {
         amount_received_ += bytes_read;
 
         if (kill_after_amount_received_ && !kill_with_io_pending_) {
           if (amount_received_ >= kill_after_amount_received_) {
             request->Cancel();
             return;
           }
         }
 
         ReadSome(request);
 
         if (kill_after_amount_received_ && kill_with_io_pending_) {
           if (amount_received_ >= kill_after_amount_received_) {
             request->Cancel();
             return;
           }
         }
       } else {
         RequestComplete();
       }
     }
 
-    void ReadSome(URLRequest* request) {
+    void ReadSome(net::URLRequest* request) {
       DCHECK(amount_received_ + kBlockSize <= kNumBlocks * kBlockSize);
       scoped_refptr<IOBuffer> wrapped_buffer(
           new net::WrappedIOBuffer(received_data_->data() + amount_received_));
       int bytes_read = 0;
       EXPECT_FALSE(request->Read(wrapped_buffer, kBlockSize, &bytes_read));
       EXPECT_EQ(0, bytes_read);
     }
 
     void RequestComplete() {
       test_->ScheduleNextTask();
     }
 
     AppCacheURLRequestJobTest* test_;
     net::HttpResponseInfo received_info_;
     scoped_refptr<net::IOBuffer> received_data_;
     bool did_receive_headers_;
     int amount_received_;
     int kill_after_amount_received_;
     bool kill_with_io_pending_;
   };
 
-  static URLRequestJob* MockHttpJobFactory(URLRequest* request,
+  static URLRequestJob* MockHttpJobFactory(net::URLRequest* request,
                                            const std::string& scheme) {
     if (mock_factory_job_) {
       URLRequestJob* temp = mock_factory_job_;
       mock_factory_job_ = NULL;
       return temp;
     } else {
       return new URLRequestErrorJob(request, net::ERR_INTERNET_DISCONNECTED);
     }
   }
 
@@ skipping 41 matching lines @@
   void RunTestOnIOThread(Method method) {
     test_finished_event_ .reset(new base::WaitableEvent(false, false));
     io_thread_->message_loop()->PostTask(
         FROM_HERE, new WrapperTask<Method>(this, method));
     test_finished_event_->Wait();
   }
 
   void SetUpTest() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
     DCHECK(task_stack_.empty());
-    orig_http_factory_ = URLRequest::RegisterProtocolFactory(
+    orig_http_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", MockHttpJobFactory);
     url_request_delegate_.reset(new MockURLRequestDelegate(this));
     storage_delegate_.reset(new MockStorageDelegate(this));
     service_.reset(new MockAppCacheService());
     expected_read_result_ = 0;
     expected_write_result_ = 0;
     written_response_id_ = 0;
     should_delete_reader_in_completion_callback_ = false;
     should_delete_writer_in_completion_callback_ = false;
     reader_deletion_count_down_ = 0;
     writer_deletion_count_down_ = 0;
     read_callback_was_called_ = false;
     write_callback_was_called_ = false;
   }
 
   void TearDownTest() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
-    URLRequest::RegisterProtocolFactory("http", orig_http_factory_);
+    net::URLRequest::RegisterProtocolFactory("http", orig_http_factory_);
     orig_http_factory_ = NULL;
     request_.reset();
     url_request_delegate_.reset();
     DCHECK(!mock_factory_job_);
 
     while (!task_stack_.empty()) {
       delete task_stack_.top().first;
       task_stack_.pop();
     }
     reader_.reset();
@@ skipping 168 matching lines @@
     return true;
   }
 
   // Individual Tests ---------------------------------------------------------
   // Some of the individual tests involve multiple async steps. Each test
   // is delineated with a section header.
 
   // Basic -------------------------------------------------------------------
   void Basic() {
     AppCacheStorage* storage = service_->storage();
-    URLRequest request(GURL("http://blah/"), NULL);
+    net::URLRequest request(GURL("http://blah/"), NULL);
     scoped_refptr<AppCacheURLRequestJob> job;
 
     // Create an instance and see that it looks as expected.
 
     job = new AppCacheURLRequestJob(&request, storage);
     EXPECT_TRUE(job->is_waiting());
     EXPECT_FALSE(job->is_delivering_appcache_response());
     EXPECT_FALSE(job->is_delivering_network_response());
     EXPECT_FALSE(job->is_delivering_error_response());
     EXPECT_FALSE(job->has_been_started());
     EXPECT_FALSE(job->has_been_killed());
     EXPECT_EQ(GURL(), job->manifest_url());
     EXPECT_EQ(kNoCacheId, job->cache_id());
     EXPECT_FALSE(job->entry().has_response_id());
 
     TestFinished();
   }
 
   // DeliveryOrders -----------------------------------------------------
   void DeliveryOrders() {
     AppCacheStorage* storage = service_->storage();
-    URLRequest request(GURL("http://blah/"), NULL);
+    net::URLRequest request(GURL("http://blah/"), NULL);
     scoped_refptr<AppCacheURLRequestJob> job;
 
     // Create an instance, give it a delivery order and see that
     // it looks as expected.
 
     job = new AppCacheURLRequestJob(&request, storage);
     job->DeliverErrorResponse();
     EXPECT_TRUE(job->is_delivering_error_response());
     EXPECT_FALSE(job->has_been_started());
 
@@ skipping 20 matching lines @@
 
   // DeliverNetworkResponse --------------------------------------------------
 
   void DeliverNetworkResponse() {
     // This test has async steps.
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::VerifyDeliverNetworkResponse));
 
     AppCacheStorage* storage = service_->storage();
     request_.reset(
-        new URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
+        new net::URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     mock_factory_job_ = new AppCacheURLRequestJob(request_.get(), storage);
     mock_factory_job_->DeliverNetworkResponse();
     EXPECT_TRUE(mock_factory_job_->is_delivering_network_response());
     EXPECT_FALSE(mock_factory_job_->has_been_started());
 
     // Start the request.
     request_->Start();
@@ skipping 11 matching lines @@
 
   // DeliverErrorResponse --------------------------------------------------
 
   void DeliverErrorResponse() {
     // This test has async steps.
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::VerifyDeliverErrorResponse));
 
     AppCacheStorage* storage = service_->storage();
     request_.reset(
-        new URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
+        new net::URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     mock_factory_job_ = new AppCacheURLRequestJob(request_.get(), storage);
     mock_factory_job_->DeliverErrorResponse();
     EXPECT_TRUE(mock_factory_job_->is_delivering_error_response());
     EXPECT_FALSE(mock_factory_job_->has_been_started());
 
     // Start the request.
     request_->Start();
 
     // The job should have been picked up.
     EXPECT_FALSE(mock_factory_job_);
     // Completion is async.
   }
 
   void VerifyDeliverErrorResponse() {
     EXPECT_EQ(request_->status().os_error(), net::ERR_FAILED);
     TestFinished();
   }
 
   // DeliverSmallAppCachedResponse --------------------------------------
   // "Small" being small enough to read completely in a single
   // request->Read call.
 
   void DeliverSmallAppCachedResponse() {
     // This test has several async steps.
     // 1. Write a small response to response storage.
-    // 2. Use URLRequest to retrieve it.
+    // 2. Use net::URLRequest to retrieve it.
     // 3. Verify we received what we expected to receive.
 
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::VerifyDeliverSmallAppCachedResponse));
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::RequestAppCachedResource, false));
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void RequestAppCachedResource(bool start_after_delivery_orders) {
     AppCacheStorage* storage = service_->storage();
     request_.reset(
-        new URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
+        new net::URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
 
     // Setup to create an AppCacheURLRequestJob with orders to deliver
     // a network response.
     scoped_refptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), storage));
 
     if (start_after_delivery_orders) {
       job->DeliverAppCachedResponse(
           GURL(), 111,
           AppCacheEntry(AppCacheEntry::EXPLICIT, written_response_id_),
@@ skipping 30 matching lines @@
                         strlen(kHttpBasicBody)));
     TestFinished();
   }
 
   // DeliverLargeAppCachedResponse --------------------------------------
   // "Large" enough to require multiple calls to request->Read to complete.
 
   void DeliverLargeAppCachedResponse() {
     // This test has several async steps.
     // 1. Write a large response to response storage.
-    // 2. Use URLRequest to retrieve it.
+    // 2. Use net::URLRequest to retrieve it.
     // 3. Verify we received what we expected to receive.
 
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::VerifyDeliverLargeAppCachedResponse));
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::RequestAppCachedResource, true));
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteLargeResponse();
@@ skipping 22 matching lines @@
     for (int i = 0; i < 3; ++i, p += kBlockSize)
       EXPECT_TRUE(CheckData(i + 1, p, kBlockSize));
     TestFinished();
   }
 
   // DeliverPartialResponse --------------------------------------
 
   void DeliverPartialResponse() {
     // This test has several async steps.
     // 1. Write a small response to response storage.
-    // 2. Use URLRequest to retrieve it a subset using a range request
+    // 2. Use net::URLRequest to retrieve it a subset using a range request
     // 3. Verify we received what we expected to receive.
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::VerifyDeliverPartialResponse));
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::MakeRangeRequest));
     writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteBasicResponse();
     // Continues async
   }
 
   void MakeRangeRequest() {
     AppCacheStorage* storage = service_->storage();
     request_.reset(
-        new URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
+        new net::URLRequest(GURL("http://blah/"), url_request_delegate_.get()));
 
     // Request a range, the 3 middle chars out of 'Hello'
     net::HttpRequestHeaders extra_headers;
     extra_headers.SetHeader("Range", "bytes= 1-3");
     request_->SetExtraRequestHeaders(extra_headers);
 
     // Create job with orders to deliver an appcached entry.
     scoped_refptr<AppCacheURLRequestJob> job(
         new AppCacheURLRequestJob(request_.get(), storage));
     job->DeliverAppCachedResponse(
@@ skipping 28 matching lines @@
     EXPECT_EQ(3, range_end);
     EXPECT_EQ(5, object_size);
     TestFinished();
   }
 
   // CancelRequest --------------------------------------
 
   void CancelRequest() {
     // This test has several async steps.
     // 1. Write a large response to response storage.
-    // 2. Use URLRequest to retrieve it.
+    // 2. Use net::URLRequest to retrieve it.
     // 3. Cancel the request after data starts coming in.
 
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::VerifyCancel));
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::RequestAppCachedResource, true));
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteLargeResponse();
 
     url_request_delegate_->kill_after_amount_received_ = kBlockSize;
     url_request_delegate_->kill_with_io_pending_ = false;
     // Continues async
   }
 
   void VerifyCancel() {
     EXPECT_EQ(URLRequestStatus::CANCELED,
               request_->status().status());
     TestFinished();
   }
 
   // CancelRequestWithIOPending --------------------------------------
 
   void CancelRequestWithIOPending() {
     // This test has several async steps.
     // 1. Write a large response to response storage.
-    // 2. Use URLRequest to retrieve it.
+    // 2. Use net::URLRequest to retrieve it.
     // 3. Cancel the request after data starts coming in.
 
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::VerifyCancel));
     PushNextTask(NewRunnableMethod(
        this, &AppCacheURLRequestJobTest::RequestAppCachedResource, true));
 
     writer_.reset(service_->storage()->CreateResponseWriter(GURL()));
     written_response_id_ = writer_->response_id();
     WriteLargeResponse();
@@ skipping 25 matching lines @@
   scoped_ptr<AppCacheResponseWriter> writer_;
   scoped_refptr<HttpResponseInfoIOBuffer> write_info_buffer_;
   scoped_refptr<IOBuffer> write_buffer_;
   int expected_write_result_;
   net::CompletionCallbackImpl<AppCacheURLRequestJobTest> write_callback_;
   net::CompletionCallbackImpl<AppCacheURLRequestJobTest> write_info_callback_;
   bool should_delete_writer_in_completion_callback_;
   int writer_deletion_count_down_;
   bool write_callback_was_called_;
 
-  URLRequest::ProtocolFactory* orig_http_factory_;
-  scoped_ptr<URLRequest> request_;
+  net::URLRequest::ProtocolFactory* orig_http_factory_;
+  scoped_ptr<net::URLRequest> request_;
   scoped_ptr<MockURLRequestDelegate> url_request_delegate_;
 
   static scoped_ptr<base::Thread> io_thread_;
   static AppCacheURLRequestJob* mock_factory_job_;
 };
 
 // static
 scoped_ptr<base::Thread> AppCacheURLRequestJobTest::io_thread_;
 AppCacheURLRequestJob* AppCacheURLRequestJobTest::mock_factory_job_ = NULL;
 
@@ skipping 31 matching lines @@
 
 TEST_F(AppCacheURLRequestJobTest, CancelRequestWithIOPending) {
   RunTestOnIOThread(&AppCacheURLRequestJobTest::CancelRequestWithIOPending);
 }
 
 }  // namespace appcache
 
 // AppCacheURLRequestJobTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheURLRequestJobTest);