net: Remove typedef net::URLRequest URLRequest;

chrome/browser/renderer_host/resource_queue_unittest.cc

 // Copyright (c) 2009 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 "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "chrome/browser/browser_thread.h"
 #include "chrome/browser/renderer_host/global_request_id.h"
 #include "chrome/browser/renderer_host/resource_dispatcher_host_request_info.h"
 #include "chrome/browser/renderer_host/resource_handler.h"
@@ skipping 82 matching lines @@
   delegate_set.insert(delegate2);
   queue->Initialize(delegate_set);
 }
 
 class NeverDelayingDelegate : public ResourceQueueDelegate {
  public:
   NeverDelayingDelegate() {
   }
 
   virtual bool ShouldDelayRequest(
-      URLRequest* request,
+      net::URLRequest* request,
       const ResourceDispatcherHostRequestInfo& request_info,
       const GlobalRequestID& request_id) {
     return false;
   }
 
   virtual void WillShutdownResourceQueue() {
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(NeverDelayingDelegate);
 };
 
 class AlwaysDelayingDelegate : public ResourceQueueDelegate {
  public:
   explicit AlwaysDelayingDelegate(ResourceQueue* resource_queue)
       : resource_queue_(resource_queue) {
   }
 
   virtual bool ShouldDelayRequest(
-      URLRequest* request,
+      net::URLRequest* request,
       const ResourceDispatcherHostRequestInfo& request_info,
       const GlobalRequestID& request_id) {
     delayed_requests_.push_back(request_id);
     return true;
   }
 
   virtual void WillShutdownResourceQueue() {
     resource_queue_ = NULL;
   }
 
@@ skipping 10 matching lines @@
  private:
   typedef std::vector<GlobalRequestID> RequestList;
 
   ResourceQueue* resource_queue_;
 
   RequestList delayed_requests_;
 
   DISALLOW_COPY_AND_ASSIGN(AlwaysDelayingDelegate);
 };
 
-class ResourceQueueTest : public testing::Test, public URLRequest::Delegate {
+class ResourceQueueTest : public testing::Test,
+                          public net::URLRequest::Delegate {
  public:
   ResourceQueueTest()
       : response_started_count_(0),
         message_loop_(MessageLoop::TYPE_IO),
         ui_thread_(BrowserThread::UI, &message_loop_),
         io_thread_(BrowserThread::IO, &message_loop_) {
   }
 
-  virtual void OnResponseStarted(URLRequest* request) {
+  virtual void OnResponseStarted(net::URLRequest* request) {
     response_started_count_++;
     // We're not going to do anything more with the request. Cancel it now
     // to avoid leaking URLRequestJob.
     request->Cancel();
   }
 
-  virtual void OnReadCompleted(URLRequest* request, int bytes_read) {
+  virtual void OnReadCompleted(net::URLRequest* request, int bytes_read) {
   }
 
  protected:
   int response_started_count_;
 
  private:
   MessageLoop message_loop_;
   BrowserThread ui_thread_;
   BrowserThread io_thread_;
 };
 
 TEST_F(ResourceQueueTest, Basic) {
   // Test the simplest lifycycle of ResourceQueue.
   ResourceQueue queue;
   queue.Initialize(ResourceQueue::DelegateSet());
   queue.Shutdown();
 }
 
 TEST_F(ResourceQueueTest, NeverDelayingDelegate) {
   ResourceQueue queue;
 
   NeverDelayingDelegate delegate;
   InitializeQueue(&queue, &delegate);
 
-  URLRequest request(GURL(kTestUrl), this);
+  net::URLRequest request(GURL(kTestUrl), this);
   scoped_ptr<ResourceDispatcherHostRequestInfo> request_info(GetRequestInfo(0));
   EXPECT_EQ(0, response_started_count_);
   queue.AddRequest(&request, *request_info.get());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(1, response_started_count_);
 
   queue.Shutdown();
 }
 
 TEST_F(ResourceQueueTest, AlwaysDelayingDelegate) {
   ResourceQueue queue;
 
   AlwaysDelayingDelegate delegate(&queue);
   InitializeQueue(&queue, &delegate);
 
-  URLRequest request(GURL(kTestUrl), this);
+  net::URLRequest request(GURL(kTestUrl), this);
   scoped_ptr<ResourceDispatcherHostRequestInfo> request_info(GetRequestInfo(0));
   EXPECT_EQ(0, response_started_count_);
   queue.AddRequest(&request, *request_info.get());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, response_started_count_);
   delegate.StartDelayedRequests();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(1, response_started_count_);
 
   queue.Shutdown();
 }
 
 TEST_F(ResourceQueueTest, AlwaysDelayingDelegateAfterShutdown) {
   ResourceQueue queue;
 
   AlwaysDelayingDelegate delegate(&queue);
   InitializeQueue(&queue, &delegate);
 
-  URLRequest request(GURL(kTestUrl), this);
+  net::URLRequest request(GURL(kTestUrl), this);
   scoped_ptr<ResourceDispatcherHostRequestInfo> request_info(GetRequestInfo(0));
   EXPECT_EQ(0, response_started_count_);
   queue.AddRequest(&request, *request_info.get());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, response_started_count_);
 
   queue.Shutdown();
 
   delegate.StartDelayedRequests();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, response_started_count_);
 }
 
 TEST_F(ResourceQueueTest, TwoDelegates) {
   ResourceQueue queue;
 
   AlwaysDelayingDelegate always_delaying_delegate(&queue);
   NeverDelayingDelegate never_delaying_delegate;
   InitializeQueue(&queue, &always_delaying_delegate, &never_delaying_delegate);
 
-  URLRequest request(GURL(kTestUrl), this);
+  net::URLRequest request(GURL(kTestUrl), this);
   scoped_ptr<ResourceDispatcherHostRequestInfo> request_info(GetRequestInfo(0));
   EXPECT_EQ(0, response_started_count_);
   queue.AddRequest(&request, *request_info.get());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, response_started_count_);
   always_delaying_delegate.StartDelayedRequests();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(1, response_started_count_);
 
   queue.Shutdown();
 }
 
 TEST_F(ResourceQueueTest, RemoveRequest) {
   ResourceQueue queue;
 
   AlwaysDelayingDelegate delegate(&queue);
   InitializeQueue(&queue, &delegate);
 
-  URLRequest request(GURL(kTestUrl), this);
+  net::URLRequest request(GURL(kTestUrl), this);
   scoped_ptr<ResourceDispatcherHostRequestInfo> request_info(GetRequestInfo(0));
   GlobalRequestID request_id(request_info->child_id(),
                              request_info->request_id());
   EXPECT_EQ(0, response_started_count_);
   queue.AddRequest(&request, *request_info.get());
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, response_started_count_);
   queue.RemoveRequest(request_id);
   delegate.StartDelayedRequests();
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, response_started_count_);
 
   queue.Shutdown();
 
   MessageLoop::current()->RunAllPending();
   EXPECT_EQ(0, response_started_count_);
 }
 
 }  // namespace