Remove all uses of EmptyString16(), EmptyWString(), and EmptyGURL(), and thei...

webkit/appcache/appcache_update_job_unittest.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// 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/url_request/url_request_test_job.h"
 #include "net/url_request/url_request_unittest.h"
@@ skipping 22 matching lines @@
   virtual void OnEventRaised(const std::vector<int>& host_ids,
                              EventID event_id) {
     raised_events_.push_back(RaisedEvent(host_ids, event_id));
 
     // Trigger additional updates if requested.
     if (event_id == start_update_trigger_ && update_) {
       for (std::vector<AppCacheHost*>::iterator it = update_hosts_.begin();
            it != update_hosts_.end(); ++it) {
         AppCacheHost* host = *it;
         update_->StartUpdate(host,
-            (host ? host->pending_master_entry_url() : GURL::EmptyGURL()));
+            (host ? host->pending_master_entry_url() : GURL()));
       }
       update_hosts_.clear();  // only trigger once
     }
   }
 
   void AddExpectedEvent(const std::vector<int>& host_ids, EventID event_id) {
     expected_events_.push_back(RaisedEvent(host_ids, event_id));
   }
 
   void TriggerAdditionalUpdates(EventID trigger_event,
@@ skipping 265 matching lines @@
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://failme"),
                                service_->storage()->NewGroupId());
 
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend mock_frontend;
     AppCacheHost host(1, &mock_frontend, service_.get());
 
-    update->StartUpdate(&host, GURL::EmptyGURL());
+    update->StartUpdate(&host, GURL());
 
     // Verify state.
     EXPECT_EQ(AppCacheUpdateJob::CACHE_ATTEMPT, update->update_type_);
     EXPECT_EQ(AppCacheUpdateJob::FETCH_MANIFEST, update->internal_state_);
     EXPECT_EQ(AppCacheGroup::CHECKING, group_->update_status());
 
     // Verify notifications.
     MockFrontend::RaisedEvents& events = mock_frontend.raised_events_;
     size_t expected = 1;
     EXPECT_EQ(expected, events.size());
@@ skipping 29 matching lines @@
       AppCacheHost host2(2, &mock_frontend2, service_.get());
       host2.AssociateCache(cache2);
 
       AppCacheHost host3(3, &mock_frontend1, service_.get());
       host3.AssociateCache(cache1);
 
       AppCacheHost host4(4, &mock_frontend3, service_.get());
 
       AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
       group_->update_job_ = update;
-      update->StartUpdate(&host4, GURL::EmptyGURL());
+      update->StartUpdate(&host4, GURL());
 
       // Verify state after starting an update.
       EXPECT_EQ(AppCacheUpdateJob::UPGRADE_ATTEMPT, update->update_type_);
       EXPECT_EQ(AppCacheUpdateJob::FETCH_MANIFEST, update->internal_state_);
       EXPECT_EQ(AppCacheGroup::CHECKING, group_->update_status());
 
       // Verify notifications.
       MockFrontend::RaisedEvents& events = mock_frontend1.raised_events_;
       size_t expected = 1;
       EXPECT_EQ(expected, events.size());
@@ skipping 26 matching lines @@
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(), GURL("http://failme"),
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     update->manifest_url_request_->SimulateError(-100);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
@@ skipping 11 matching lines @@
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCache(cache);
     host2->AssociateCache(cache);
 
-    update->StartUpdate(NULL, GURL::EmptyGURL());
+    update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     update->manifest_url_request_->SimulateError(-100);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_newest_cache_ = cache;  // newest cache unaffected by update
     MockFrontend::HostIds ids1(1, host1->host_id());
@@ skipping 14 matching lines @@
     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);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;  // redirect is like a failed request
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void ManifestWrongMimeTypeTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), http_server_->TestServerPage("defaultresponse"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;  // bad mime type is like a failed request
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
@@ skipping 10 matching lines @@
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCache(cache);
     host2->AssociateCache(cache);
 
-    update->StartUpdate(NULL, GURL::EmptyGURL());
+    update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = true;
     expect_group_has_cache_ = true;
     expect_newest_cache_ = cache;  // newest cache unaffected by update
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, OBSOLETE_EVENT);
     MockFrontend::HostIds ids2(1, host2->host_id());
     frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
     frontend2->AddExpectedEvent(ids2, OBSOLETE_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void ManifestGoneTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), http_server_->TestServerPage("files/gone"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = true;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void CacheAttemptNotModifiedTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), http_server_->TestServerPage("files/notmodified"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;  // treated like cache failure
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
@@ skipping 10 matching lines @@
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCache(cache);
     host2->AssociateCache(cache);
 
-    update->StartUpdate(NULL, GURL::EmptyGURL());
+    update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_newest_cache_ = cache;  // newest cache unaffected by update
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, NO_UPDATE_EVENT);
@@ skipping 56 matching lines @@
 
     // Start update after data write completes asynchronously.
   }
 
   void StartUpdateAfterSeedingStorageData(int result) {
     ASSERT_GT(result, 0);
     write_callback_.reset();
     response_writer_.reset();
 
     AppCacheUpdateJob* update = group_->update_job_;
-    update->StartUpdate(NULL, GURL::EmptyGURL());
+    update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     WaitForUpdateToFinish();
   }
 
   void BasicCacheAttemptSuccessTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     MakeService();
     group_ = new AppCacheGroup(
         service_.get(), http_server_->TestServerPage("files/manifest1"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     tested_manifest_ = MANIFEST1;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
@@ skipping 249 matching lines @@
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCache(cache);
     host2->AssociateCache(cache);
 
     // Give the newest cache a master entry that is also one of the explicit
     // entries in the manifest.
     cache->AddEntry(http_server_->TestServerPage("files/explicit1"),
                     AppCacheEntry(AppCacheEntry::MASTER, 111));
 
-    update->StartUpdate(NULL, GURL::EmptyGURL());
+    update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_old_cache_ = cache;
     tested_manifest_ = MANIFEST_MERGED_TYPES;
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
@@ skipping 20 matching lines @@
 
     MakeService();
     group_ = new AppCacheGroup(service_.get(),
         http_server_->TestServerPage("files/manifest-with-404"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;  // 404 explicit url is cache failure
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
@@ skipping 10 matching lines @@
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 99);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCache(cache);
     host2->AssociateCache(cache);
 
-    update->StartUpdate(NULL, GURL::EmptyGURL());
+    update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_newest_cache_ = cache;  // newest cache unaffectd by failed update
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, DOWNLOADING_EVENT);
@@ skipping 34 matching lines @@
     cache->AddEntry(
         http_server_->TestServerPage("files/notfound"),
         AppCacheEntry(AppCacheEntry::MASTER, 222));
     cache->AddEntry(
         http_server_->TestServerPage("files/explicit2"),
         AppCacheEntry(AppCacheEntry::MASTER | AppCacheEntry::FOREIGN, 333));
     cache->AddEntry(
         http_server_->TestServerPage("files/servererror"),
         AppCacheEntry(AppCacheEntry::MASTER, 444));
 
-    update->StartUpdate(NULL, GURL::EmptyGURL());
+    update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_old_cache_ = cache;
     tested_manifest_ = MANIFEST1;
     expect_extra_entries_.insert(AppCache::EntryMap::value_type(
         http_server_->TestServerPage("files/explicit2"),
@@ skipping 42 matching lines @@
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 33);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCache(cache);
     host2->AssociateCache(cache);
 
-    update->StartUpdate(NULL, GURL::EmptyGURL());
+    update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_old_cache_ = cache;
     tested_manifest_ = EMPTY_MANIFEST;
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
@@ skipping 15 matching lines @@
         http_server_->TestServerPage("files/empty-file-manifest"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 22);
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
     host->AssociateCache(cache);
 
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     tested_manifest_ = EMPTY_FILE_MANIFEST;
     MockFrontend::HostIds ids1(1, host->host_id());
     frontend->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend->AddExpectedEvent(ids1, DOWNLOADING_EVENT);
@@ skipping 14 matching lines @@
     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();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
@@ skipping 10 matching lines @@
     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();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
@@ skipping 11 matching lines @@
     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();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
@@ skipping 10 matching lines @@
     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();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
@@ skipping 10 matching lines @@
     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();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
 
   void FailStoreNewestCacheTest() {
     ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
 
     MakeService();
     MockAppCacheStorage* storage =
         reinterpret_cast<MockAppCacheStorage*>(service_->storage());
     storage->SimulateStoreGroupAndNewestCacheFailure();
 
     group_ = new AppCacheGroup(
         service_.get(), http_server_->TestServerPage("files/manifest1"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;  // storage failed
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
   }
@@ skipping 13 matching lines @@
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 11);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCache(cache);
     host2->AssociateCache(cache);
 
-    update->StartUpdate(NULL, GURL::EmptyGURL());
+    update->StartUpdate(NULL, GURL());
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_newest_cache_ = cache;  // unchanged
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, DOWNLOADING_EVENT);
     frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);
@@ skipping 18 matching lines @@
     storage->SimulateMakeGroupObsoleteFailure();
 
     group_ = new AppCacheGroup(
         service_.get(), http_server_->TestServerPage("files/gone"),
         service_->storage()->NewGroupId());
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
     AppCacheHost* host = MakeHost(1, frontend);
-    update->StartUpdate(host, GURL::EmptyGURL());
+    update->StartUpdate(host, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = false;
     frontend->AddExpectedEvent(MockFrontend::HostIds(1, host->host_id()),
                                CHECKING_EVENT);
 
     WaitForUpdateToFinish();
@@ skipping 14 matching lines @@
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(1, 111);
     MockFrontend* frontend1 = MakeMockFrontend();
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host1->AssociateCache(cache);
     host2->AssociateCache(cache);
 
-    update->StartUpdate(NULL, GURL::EmptyGURL());
+    update->StartUpdate(NULL, GURL());
     EXPECT_TRUE(update->manifest_url_request_ != NULL);
 
     // Set up checks for when update job finishes.
     do_checks_after_update_finished_ = true;
     expect_group_obsolete_ = false;
     expect_group_has_cache_ = true;
     expect_newest_cache_ = cache;  // newest cache unaffected by update
     MockFrontend::HostIds ids1(1, host1->host_id());
     frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
     frontend1->AddExpectedEvent(ids1, ERROR_EVENT);
@@ skipping 530 matching lines @@
     group_ = new AppCacheGroup(
         service_.get(), http_server_->TestServerPage("files/manifest1"), 111);
     AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
     group_->update_job_ = update;
 
     AppCache* cache = MakeCacheForGroup(service_->storage()->NewCacheId(), 42);
     MockFrontend* frontend1 = MakeMockFrontend();
     AppCacheHost* host1 = MakeHost(1, frontend1);
     host1->AssociateCache(cache);
 
-    update->StartUpdate(NULL, GURL::EmptyGURL());
+    update->StartUpdate(NULL, GURL());
 
     // Set up additional updates to be started while update is in progress.
     MockFrontend* frontend2 = MakeMockFrontend();
     AppCacheHost* host2 = MakeHost(2, frontend2);
     host2->new_master_entry_url_ =
         http_server_->TestServerPage("files/explicit1");
 
     MockFrontend* frontend3 = MakeMockFrontend();
     AppCacheHost* host3 = MakeHost(3, frontend3);
     host3->new_master_entry_url_ =
@@ skipping 106 matching lines @@
     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.
     HttpHeadersRequestTestJob::Initialize("", "");
     MockFrontend mock_frontend;
     AppCacheHost host(1, &mock_frontend, service_.get());
-    update->StartUpdate(&host, GURL::EmptyGURL());
+    update->StartUpdate(&host, GURL());
     HttpHeadersRequestTestJob::Verify();
     delete update;
 
     // Now simulate a refetch manifest request. Will start fetch request
     // synchronously.
     const char data[] =
         "HTTP/1.1 200 OK\0"
         "\0";
     net::HttpResponseHeaders* headers =
         new net::HttpResponseHeaders(std::string(data, arraysize(data)));
@@ skipping 581 matching lines @@
   scoped_refptr<AppCacheGroup> group =
       new AppCacheGroup(&service, GURL("http://manifesturl.com"),
                         service.storage()->NewGroupId());
 
   AppCacheUpdateJob update(&service, group);
 
   // Pretend group is in checking state.
   group->update_job_ = &update;
   group->update_status_ = AppCacheGroup::CHECKING;
 
-  update.StartUpdate(NULL, GURL::EmptyGURL());
+  update.StartUpdate(NULL, GURL());
   EXPECT_EQ(AppCacheGroup::CHECKING, group->update_status());
 
   MockFrontend mock_frontend;
   AppCacheHost host(1, &mock_frontend, &service);
-  update.StartUpdate(&host, GURL::EmptyGURL());
+  update.StartUpdate(&host, GURL());
 
   MockFrontend::RaisedEvents events = mock_frontend.raised_events_;
   size_t expected = 1;
   EXPECT_EQ(expected, events.size());
   EXPECT_EQ(expected, events[0].first.size());
   EXPECT_EQ(host.host_id(), events[0].first[0]);
   EXPECT_EQ(CHECKING_EVENT, events[0].second);
   EXPECT_EQ(AppCacheGroup::CHECKING, group->update_status());
 }
 
 TEST_F(AppCacheUpdateJobTest, AlreadyDownloading) {
   MockAppCacheService service;
   scoped_refptr<AppCacheGroup> group =
       new AppCacheGroup(&service, GURL("http://manifesturl.com"),
                         service.storage()->NewGroupId());
 
   AppCacheUpdateJob update(&service, group);
 
   // Pretend group is in downloading state.
   group->update_job_ = &update;
   group->update_status_ = AppCacheGroup::DOWNLOADING;
 
-  update.StartUpdate(NULL, GURL::EmptyGURL());
+  update.StartUpdate(NULL, GURL());
   EXPECT_EQ(AppCacheGroup::DOWNLOADING, group->update_status());
 
   MockFrontend mock_frontend;
   AppCacheHost host(1, &mock_frontend, &service);
-  update.StartUpdate(&host, GURL::EmptyGURL());
+  update.StartUpdate(&host, GURL());
 
   MockFrontend::RaisedEvents events = mock_frontend.raised_events_;
   size_t expected = 2;
   EXPECT_EQ(expected, events.size());
   expected = 1;
   EXPECT_EQ(expected, events[0].first.size());
   EXPECT_EQ(host.host_id(), events[0].first[0]);
   EXPECT_EQ(CHECKING_EVENT, events[0].second);
 
   EXPECT_EQ(expected, events[1].first.size());
@@ skipping 194 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, IfNoneMatchRefetch) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::IfNoneMatchRefetchTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, MultipleHeadersRefetch) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::MultipleHeadersRefetchTest);
 }
 
 }  // namespace appcache