net: Remove typedef net::URLRequest URLRequest;

webkit/blob/blob_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/file_path.h"
 #include "base/file_util.h"
 #include "base/scoped_temp_dir.h"
@@ skipping 23 matching lines @@
 static const char kTestFileData2[] = "This is sample file.";
 static const char kTestContentType[] = "foo/bar";
 static const char kTestContentDisposition[] = "attachment; filename=foo.txt";
 
 class BlobURLRequestJobTest : public testing::Test {
  public:
 
   // Test Harness -------------------------------------------------------------
   // TODO(jianli): share this test harness with AppCacheURLRequestJobTest
 
-  class MockURLRequestDelegate : public URLRequest::Delegate {
+  class MockURLRequestDelegate : public net::URLRequest::Delegate {
    public:
     explicit MockURLRequestDelegate(BlobURLRequestJobTest* test)
         : test_(test),
           received_data_(new net::IOBuffer(kBufferSize)) {
     }
 
-    virtual void OnResponseStarted(URLRequest* request) {
+    virtual void OnResponseStarted(net::URLRequest* request) {
       if (request->status().is_success()) {
         EXPECT_TRUE(request->response_headers());
         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)
          ReceiveData(request, bytes_read);
        else
          RequestComplete();
     }
 
     const std::string& response_data() const { return response_data_; }
 
    private:
-    void ReadSome(URLRequest* request) {
+    void ReadSome(net::URLRequest* request) {
       if (request->job()->is_done()) {
         RequestComplete();
         return;
       }
 
       int bytes_read = 0;
       if (!request->Read(received_data_.get(), kBufferSize, &bytes_read)) {
         if (!request->status().is_io_pending()) {
           RequestComplete();
         }
         return;
       }
 
       ReceiveData(request, bytes_read);
     }
 
-    void ReceiveData(URLRequest* request, int bytes_read) {
+    void ReceiveData(net::URLRequest* request, int bytes_read) {
       if (bytes_read) {
         response_data_.append(received_data_->data(),
                               static_cast<size_t>(bytes_read));
         ReadSome(request);
       } else {
         RequestComplete();
       }
     }
 
     void RequestComplete() {
@@ skipping 45 matching lines @@
 
     io_thread_.reset(new base::Thread("BlobRLRequestJobTest Thread"));
     base::Thread::Options options(MessageLoop::TYPE_IO, 0);
     io_thread_->StartWithOptions(options);
   }
 
   void TearDown() {
     io_thread_.reset(NULL);
   }
 
-  static URLRequestJob* BlobURLRequestJobFactory(URLRequest* request,
+  static URLRequestJob* BlobURLRequestJobFactory(net::URLRequest* request,
                                                  const std::string& scheme) {
     BlobURLRequestJob* temp = blob_url_request_job_;
     blob_url_request_job_ = NULL;
     return temp;
   }
 
   BlobURLRequestJobTest()
       : expected_status_code_(0) {
   }
 
   template <class Method>
   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());
 
-    URLRequest::RegisterProtocolFactory("blob", &BlobURLRequestJobFactory);
+    net::URLRequest::RegisterProtocolFactory("blob", &BlobURLRequestJobFactory);
     url_request_delegate_.reset(new MockURLRequestDelegate(this));
   }
 
   void TearDownTest() {
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
 
     request_.reset();
     url_request_delegate_.reset();
 
     DCHECK(!blob_url_request_job_);
-    URLRequest::RegisterProtocolFactory("blob", NULL);
+    net::URLRequest::RegisterProtocolFactory("blob", NULL);
   }
 
   void TestFinished() {
     // We unwind the stack prior to finishing up to let stack
     // based objects get deleted.
     DCHECK(MessageLoop::current() == io_thread_->message_loop());
     MessageLoop::current()->PostTask(FROM_HERE,
         NewRunnableMethod(
             this, &BlobURLRequestJobTest::TestFinishedUnwound));
   }
@@ skipping 41 matching lines @@
         this, &BlobURLRequestJobTest::VerifyResponse));
     expected_status_code_ = expected_status_code;
     expected_response_ = "";
     return TestRequest("GET", net::HttpRequestHeaders(), blob_data);
   }
 
   void TestRequest(const std::string& method,
                    const net::HttpRequestHeaders& extra_headers,
                    BlobData* blob_data) {
     // This test has async steps.
-    request_.reset(new URLRequest(GURL("blob:blah"),
-                                  url_request_delegate_.get()));
+    request_.reset(new net::URLRequest(GURL("blob:blah"),
+                                       url_request_delegate_.get()));
     request_->set_method(method);
     blob_url_request_job_ = new BlobURLRequestJob(request_.get(),
                                                   blob_data, NULL);
 
     // Start the request.
     if (!extra_headers.IsEmpty())
       request_->SetExtraRequestHeaders(extra_headers);
     request_->Start();
 
     // Completion is async.
@@ skipping 124 matching lines @@
   ScopedTempDir temp_dir_;
   FilePath temp_file1_;
   FilePath temp_file2_;
   base::Time temp_file_modification_time1_;
   base::Time temp_file_modification_time2_;
   scoped_ptr<base::Thread> io_thread_;
   static BlobURLRequestJob* blob_url_request_job_;
 
   scoped_ptr<base::WaitableEvent> test_finished_event_;
   std::stack<std::pair<Task*, bool> > task_stack_;
-  scoped_ptr<URLRequest> request_;
+  scoped_ptr<net::URLRequest> request_;
   scoped_ptr<MockURLRequestDelegate> url_request_delegate_;
   int expected_status_code_;
   std::string expected_response_;
 };
 
 // static
 BlobURLRequestJob* BlobURLRequestJobTest::blob_url_request_job_ = NULL;
 
 TEST_F(BlobURLRequestJobTest, TestGetSimpleDataRequest) {
   RunTestOnIOThread(&BlobURLRequestJobTest::TestGetSimpleDataRequest);
@@ skipping 34 matching lines @@
 
 TEST_F(BlobURLRequestJobTest, TestExtraHeaders) {
   RunTestOnIOThread(&BlobURLRequestJobTest::TestExtraHeaders);
 }
 
 }  // namespace webkit_blob
 
 // BlobURLRequestJobTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(webkit_blob::BlobURLRequestJobTest);