net: Remove typedef net::URLRequest URLRequest;

webkit/appcache/appcache_update_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 "testing/gtest/include/gtest/gtest.h"
 
 #include "base/stl_util-inl.h"
 #include "base/thread.h"
 #include "base/waitable_event.h"
 #include "net/base/net_errors.h"
@@ skipping 23 matching lines @@
 
 // There are a handful of http accessible resources that we need to conduct
 // these tests. Instead of running a seperate server to host these resources,
 // we mock them up.
 class MockHttpServer {
  public:
   static GURL GetMockUrl(const std::string& path) {
     return GURL("http://mockhost/" + path);
   }
 
-  static URLRequestJob* JobFactory(URLRequest* request,
+  static URLRequestJob* JobFactory(net::URLRequest* request,
                                    const std::string& scheme) {
     if (request->url().host() != "mockhost")
       return new URLRequestErrorJob(request, -1);
 
     std::string headers, body;
     GetMockResponse(request->url().path(), &headers, &body);
     return new URLRequestTestJob(request, headers, body, true);
   }
 
  private:
@@ skipping 225 matching lines @@
   int last_progress_total_;
   int last_progress_complete_;
 
   // Add ability for frontend to add master entries to an inprogress update.
   EventID start_update_trigger_;
   AppCacheUpdateJob* update_;
   std::vector<AppCacheHost*> update_hosts_;
 };
 
 // Helper factories to simulate redirected URL responses for tests.
-static URLRequestJob* RedirectFactory(URLRequest* request,
+static URLRequestJob* RedirectFactory(net::URLRequest* request,
                                       const std::string& scheme) {
   return new URLRequestTestJob(request,
                                URLRequestTestJob::test_redirect_headers(),
                                URLRequestTestJob::test_data_1(),
                                true);
 }
 
 // Helper class to simulate a URL that returns retry or success.
 class RetryRequestTestJob : public URLRequestTestJob {
  public:
@@ skipping 14 matching lines @@
     expected_requests_ = expected_requests;
   }
 
   // Verifies results at end of test and resets counters.
   static void Verify() {
     EXPECT_EQ(expected_requests_, num_requests_);
     num_requests_ = 0;
     expected_requests_ = 0;
   }
 
-  static URLRequestJob* RetryFactory(URLRequest* request,
+  static URLRequestJob* RetryFactory(net::URLRequest* request,
                                      const std::string& scheme) {
     ++num_requests_;
     if (num_retries_ > 0 && request->original_url() == kRetryUrl) {
       --num_retries_;
       return new RetryRequestTestJob(
           request, RetryRequestTestJob::retry_headers(), 503);
     } else {
       return new RetryRequestTestJob(
           request, RetryRequestTestJob::manifest_headers(), 200);
     }
@@ skipping 34 matching lines @@
         "Content-type: text/cache-manifest\0"
         "\0";
     return std::string(headers, arraysize(headers));
   }
 
   static std::string data() {
     return std::string("CACHE MANIFEST\r"
         "http://retry\r");  // must be same as kRetryUrl
   }
 
-  explicit RetryRequestTestJob(URLRequest* request, const std::string& headers,
+  explicit RetryRequestTestJob(net::URLRequest* request,
+                               const std::string& headers,
                                int response_code)
       : URLRequestTestJob(request, headers, data(), true),
         response_code_(response_code) {
   }
 
   int response_code_;
 
   static int num_requests_;
   static int num_retries_;
   static RetryHeader retry_after_;
@@ skipping 25 matching lines @@
       EXPECT_TRUE(saw_if_none_match_);
 
     // Reset.
     expect_if_modified_since_.clear();
     saw_if_modified_since_ = false;
     expect_if_none_match_.clear();
     saw_if_none_match_ = false;
     already_checked_ = false;
   }
 
-  static URLRequestJob* IfModifiedSinceFactory(URLRequest* request,
+  static URLRequestJob* IfModifiedSinceFactory(net::URLRequest* request,
                                                const std::string& scheme) {
     if (!already_checked_) {
       already_checked_ = true;  // only check once for a test
       const net::HttpRequestHeaders& extra_headers =
           request->extra_request_headers();
       std::string header_value;
       saw_if_modified_since_ =
           extra_headers.GetHeader(
               net::HttpRequestHeaders::kIfModifiedSince, &header_value) &&
           header_value == expect_if_modified_since_;
@@ skipping 33 matching lines @@
     // We cannot rely on our base class to stop the thread since we want our
     // CleanUp function to run.
     Stop();
   }
 
   const scoped_refptr<URLRequestContext>& request_context() {
     return request_context_;
   }
 
   virtual void Init() {
-    old_factory_ = URLRequest::RegisterProtocolFactory(
+    old_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", MockHttpServer::JobFactory);
     request_context_ = new TestURLRequestContext();
   }
 
   virtual void CleanUp() {
-    URLRequest::RegisterProtocolFactory("http", old_factory_);
+    net::URLRequest::RegisterProtocolFactory("http", old_factory_);
     request_context_ = NULL;
   }
 
-  URLRequest::ProtocolFactory* old_factory_;
+  net::URLRequest::ProtocolFactory* old_factory_;
   scoped_refptr<URLRequestContext> request_context_;
 };
 
 }  // namespace
 
 class AppCacheUpdateJobTest : public testing::Test,
                               public AppCacheGroup::UpdateObserver {
  public:
   class MockAppCachePolicy : public AppCachePolicy {
    public:
@@ skipping 282 matching lines @@
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, ERROR_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void ManifestRedirectTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     old_factory_ =
-        URLRequest::RegisterProtocolFactory("http", RedirectFactory);
+        net::URLRequest::RegisterProtocolFactory("http", RedirectFactory);
     registered_factory_ = true;
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://testme"),
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
@@ skipping 770 matching lines @@
 
     WaitForUpdateToFinish();
   }
 
   void RetryRequestTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Set some large number of times to return retry.
     // Expect 1 manifest fetch and 3 retries.
     RetryRequestTestJob::Initialize(5, RetryRequestTestJob::RETRY_AFTER_0, 4);
-    old_factory_ = URLRequest::RegisterProtocolFactory(
+    old_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", RetryRequestTestJob::RetryFactory);
     registered_factory_ = true;
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
@@ skipping 10 matching lines @@
 
     WaitForUpdateToFinish();
   }
 
   void RetryNoRetryAfterTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Set some large number of times to return retry.
     // Expect 1 manifest fetch and 0 retries.
     RetryRequestTestJob::Initialize(5, RetryRequestTestJob::NO_RETRY_AFTER, 1);
-    old_factory_ = URLRequest::RegisterProtocolFactory(
+    old_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", RetryRequestTestJob::RetryFactory);
     registered_factory_ = true;
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
@@ skipping 11 matching lines @@
     WaitForUpdateToFinish();
   }
 
   void RetryNonzeroRetryAfterTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Set some large number of times to return retry.
     // Expect 1 request and 0 retry attempts.
     RetryRequestTestJob::Initialize(
         5, RetryRequestTestJob::NONZERO_RETRY_AFTER, 1);
-    old_factory_ = URLRequest::RegisterProtocolFactory(
+    old_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", RetryRequestTestJob::RetryFactory);
     registered_factory_ = true;
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
@@ skipping 10 matching lines @@
 
     WaitForUpdateToFinish();
   }
 
   void RetrySuccessTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Set 2 as the retry limit (does not exceed the max).
     // Expect 1 manifest fetch, 2 retries, 1 url fetch, 1 manifest refetch.
     RetryRequestTestJob::Initialize(2, RetryRequestTestJob::RETRY_AFTER_0, 5);
-    old_factory_ = URLRequest::RegisterProtocolFactory(
+    old_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", RetryRequestTestJob::RetryFactory);
     registered_factory_ = true;
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
@@ skipping 10 matching lines @@
 
     WaitForUpdateToFinish();
   }
 
   void RetryUrlTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Set 1 as the retry limit (does not exceed the max).
     // Expect 1 manifest fetch, 1 url fetch, 1 url retry, 1 manifest refetch.
     RetryRequestTestJob::Initialize(1, RetryRequestTestJob::RETRY_AFTER_0, 4);
-    old_factory_ = URLRequest::RegisterProtocolFactory(
+    old_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", RetryRequestTestJob::RetryFactory);
     registered_factory_ = true;
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://retryurl"),
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
@@ skipping 820 matching lines @@
     frontend->AddExpectedEvent(ids1, PROGRESS_EVENT);  // final
     frontend->AddExpectedEvent(ids1, CACHED_EVENT);
 
     // Group status will be IDLE so cannot call WaitForUpdateToFinish.
     group_->AddUpdateObserver(this);
   }
 
   void IfModifiedSinceTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
-    old_factory_ = URLRequest::RegisterProtocolFactory(
+    old_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", HttpHeadersRequestTestJob::IfModifiedSinceFactory);
     registered_factory_ = true;
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://headertest"), 111);
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     // First test against a cache attempt. Will start manifest fetch
     // synchronously.
@@ skipping 45 matching lines @@
     HttpHeadersRequestTestJob::Verify();
     delete update;
 
     UpdateFinished();
   }
 
   void IfModifiedSinceUpgradeTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     HttpHeadersRequestTestJob::Initialize("Sat, 29 Oct 1994 19:43:31 GMT", "");
-    old_factory_ = URLRequest::RegisterProtocolFactory(
+    old_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", HttpHeadersRequestTestJob::IfModifiedSinceFactory);
     registered_factory_ = true;
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), MockHttpServer::GetMockUrl("files/manifest1"), 111);
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     // Give the newest cache a manifest enry that is in storage.
@@ skipping 37 matching lines @@
             &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
     response_writer_->WriteInfo(io_buffer, write_callback_.get());
 
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchUpgradeTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     HttpHeadersRequestTestJob::Initialize("", "\"LadeDade\"");
-    old_factory_ = URLRequest::RegisterProtocolFactory(
+    old_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", HttpHeadersRequestTestJob::IfModifiedSinceFactory);
     registered_factory_ = true;
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), MockHttpServer::GetMockUrl("files/manifest1"), 111);
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     // Give the newest cache a manifest enry that is in storage.
@@ skipping 37 matching lines @@
             &AppCacheUpdateJobTest::StartUpdateAfterSeedingStorageData));
     response_writer_->WriteInfo(io_buffer, write_callback_.get());
 
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchRefetchTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     HttpHeadersRequestTestJob::Initialize("", "\"LadeDade\"");
-    old_factory_ = URLRequest::RegisterProtocolFactory(
+    old_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", HttpHeadersRequestTestJob::IfModifiedSinceFactory);
     registered_factory_ = true;
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://headertest"), 111);
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     // Simulate a refetch manifest request that uses an ETag header.
     const char data[] =
@@ skipping 14 matching lines @@
 
     UpdateFinished();
   }
 
   void MultipleHeadersRefetchTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     // Verify that code is correct when building multiple extra headers.
     HttpHeadersRequestTestJob::Initialize(
         "Sat, 29 Oct 1994 19:43:31 GMT", "\"LadeDade\"");
-    old_factory_ = URLRequest::RegisterProtocolFactory(
+    old_factory_ = net::URLRequest::RegisterProtocolFactory(
         "http", HttpHeadersRequestTestJob::IfModifiedSinceFactory);
     registered_factory_ = true;
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://headertest"), 111);
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     // Simulate a refetch manifest request that uses an ETag header.
     const char data[] =
@@ skipping 46 matching lines @@
       VerifyExpectations();
 
     // Clean up everything that was created on the IO thread.
     protect_newest_cache_ = NULL;
     group_ = NULL;
     STLDeleteContainerPointers(hosts_.begin(), hosts_.end());
     STLDeleteContainerPointers(frontends_.begin(), frontends_.end());
     response_infos_.clear();
     service_.reset(NULL);
     if (registered_factory_)
-      URLRequest::RegisterProtocolFactory("http", old_factory_);
+      net::URLRequest::RegisterProtocolFactory("http", old_factory_);
 
     event_->Signal();
   }
 
   void MakeService() {
     service_.reset(new MockAppCacheService());
     service_->set_request_context(io_thread_->request_context());
     service_->set_appcache_policy(&policy_);
   }
 
@@ skipping 328 matching lines @@
   AppCache* expect_old_cache_;
   AppCache* expect_newest_cache_;
   bool expect_non_null_update_time_;
   std::vector<MockFrontend*> frontends_;  // to check expected events
   TestedManifest tested_manifest_;
   const char* tested_manifest_path_override_;
   AppCache::EntryMap expect_extra_entries_;
   std::map<GURL, int64> expect_response_ids_;
 
   bool registered_factory_;
-  URLRequest::ProtocolFactory* old_factory_;
+  net::URLRequest::ProtocolFactory* old_factory_;
 };
 
 // static
 IOThread* AppCacheUpdateJobTest::io_thread_ = NULL;
 base::WaitableEvent* AppCacheUpdateJobTest::io_thread_shutdown_event_ = NULL;
 
 
 TEST_F(AppCacheUpdateJobTest, AlreadyChecking) {
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group(
@@ skipping 262 matching lines @@
   RunTestOnIOThread(&AppCacheUpdateJobTest::MultipleHeadersRefetchTest);
 }
 
 }  // namespace appcache
 
 // AppCacheUpdateJobTest is expected to always live longer than the
 // runnable methods.  This lets us call NewRunnableMethod on its instances.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(appcache::AppCacheUpdateJobTest);
 DISABLE_RUNNABLE_METHOD_REFCOUNT(
     appcache::AppCacheUpdateJobTest::MockAppCachePolicy);