Implementation of application cache update algorithm....

webkit/appcache/appcache_update_job_unittest.cc

+// Copyright (c) 2009 The Chromium Authos. 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"
+#include "webkit/appcache/appcache_group.h"
+#include "webkit/appcache/appcache_host.h"
+#include "webkit/appcache/appcache_service.h"
+#include "webkit/appcache/appcache_update_job.h"
+
+namespace appcache {
+class AppCacheUpdateJobTest;
+
+const wchar_t kDocRoot[] = L"webkit/appcache/data/appcache_unittest";
+
+class MockFrontend : public AppCacheFrontend {
+ public:
+  virtual void OnCacheSelected(int host_id, int64 cache_id,
+                               Status status) {
+  }
+
+  virtual void OnStatusChanged(const std::vector<int>& host_ids,
+                               Status status) {
+  }
+
+  virtual void OnEventRaised(const std::vector<int>& host_ids,
+                             EventID event_id) {
+    raised_events_.push_back(RaisedEvent(host_ids, event_id));
+  }
+
+  void AddExpectedEvent(const std::vector<int>& host_ids, EventID event_id) {
+    expected_events_.push_back(RaisedEvent(host_ids, event_id));
+  }
+
+  typedef std::vector<int> HostIds;
+  typedef std::pair<HostIds, EventID> RaisedEvent;
+  typedef std::vector<RaisedEvent> RaisedEvents;
+  RaisedEvents raised_events_;
+
+  // Set the expected events if verification needs to happen asynchronously.
+  RaisedEvents expected_events_;
+};
+
+// Helper class to let us call methods of AppCacheUpdateJobTest on a
+// thread of our choice.
+template <class Method>
+class WrapperTask : public Task {
+ public:
+  WrapperTask(AppCacheUpdateJobTest* test, Method method)
+      : test_(test),
+        method_(method) {
+  }
+
+  virtual void Run() {
+    (test_->*method_)( );
+  }
+
+ private:
+  AppCacheUpdateJobTest* test_;
+  Method method_;
+};
+
+// Helper factories to simulate redirected URL responses for tests.
+static URLRequestJob* RedirectFactory(URLRequest* request,
+                                      const std::string& scheme) {
+  return new URLRequestTestJob(request,
+                               URLRequestTestJob::test_redirect_headers(),
+                               URLRequestTestJob::test_data_1(),
+                               true);
+}
+
+class AppCacheUpdateJobTest : public testing::Test,
+                              public AppCacheGroup::Observer {
+ public:
+  AppCacheUpdateJobTest()
+      : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+        do_checks_after_update_finished_(false),
+        expect_group_obsolete_(false),
+        expect_group_has_cache_(false),
+        expect_old_cache_(NULL),
+        expect_newest_cache_(NULL),
+        tested_manifest_(NONE) {
+  }
+
+  static void SetUpTestCase() {
+    io_thread_.reset(new base::Thread("AppCacheUpdateJob IO  test thread"));
+    base::Thread::Options options(MessageLoop::TYPE_IO, 0);
+    io_thread_->StartWithOptions(options);
+
+    http_server_ =
+        HTTPTestServer::CreateServer(kDocRoot, io_thread_->message_loop());
+    ASSERT_TRUE(http_server_);
+  }
+
+  static void TearDownTestCase() {
+    http_server_ = NULL;
+    io_thread_.reset(NULL);
+  }
+
+  // Use a separate IO thread to run a test. Thread will be destroyed
+  // when it goes out of scope.
+  template <class Method>
+  void RunTestOnIOThread(Method method) {
+    event_ .reset(new base::WaitableEvent(false, false));
+    io_thread_->message_loop()->PostTask(
+        FROM_HERE, new WrapperTask<Method>(this, method));
+
+    // Wait until task is done before exiting the test.
+    event_->Wait();
+  }
+
+  void StartCacheAttemptTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(service_.get(), GURL("http://failme"));
+
+    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());
+
+    // 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());
+    EXPECT_EQ(expected, events[0].first.size());
+    EXPECT_EQ(host.host_id(), events[0].first[0]);
+    EXPECT_EQ(CHECKING_EVENT, events[0].second);
+
+    // Abort as we're not testing actual URL fetches in this test.
+    delete update;
+    UpdateFinished();
+  }
+
+  void StartUpgradeAttemptTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    {
+      MakeService();
+      group_ = new AppCacheGroup(service_.get(), GURL("http://failme"));
+
+      // Give the group some existing caches.
+      AppCache* cache1 = MakeCacheForGroup(1);
+      AppCache* cache2 = MakeCacheForGroup(2);
+
+      // Associate some hosts with caches in the group.
+      MockFrontend mock_frontend1;
+      MockFrontend mock_frontend2;
+      MockFrontend mock_frontend3;
+
+      AppCacheHost host1(1, &mock_frontend1, service_.get());
+      host1.AssociateCache(cache1);
+
+      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());
+
+      // 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());
+      expected = 2;  // 2 hosts using frontend1
+      EXPECT_EQ(expected, events[0].first.size());
+      MockFrontend::HostIds& host_ids = events[0].first;
+      EXPECT_TRUE(std::find(host_ids.begin(), host_ids.end(), host1.host_id())
+          != host_ids.end());
+      EXPECT_TRUE(std::find(host_ids.begin(), host_ids.end(), host3.host_id())
+          != host_ids.end());
+      EXPECT_EQ(CHECKING_EVENT, events[0].second);
+
+      events = mock_frontend2.raised_events_;
+      expected = 1;
+      EXPECT_EQ(expected, events.size());
+      EXPECT_EQ(expected, events[0].first.size());  // 1 host using frontend2
+      EXPECT_EQ(host2.host_id(), events[0].first[0]);
+      EXPECT_EQ(CHECKING_EVENT, events[0].second);
+
+      events = mock_frontend3.raised_events_;
+      EXPECT_TRUE(events.empty());
+
+      // Abort as we're not testing actual URL fetches in this test.
+      delete update;
+    }
+    UpdateFinished();
+  }
+
+  void CacheAttemptFetchManifestFailTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(service_.get(), GURL("http://failme"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    MockFrontend* frontend = MakeMockFrontend();
+    AppCacheHost* host = MakeHost(1, frontend);
+    update->StartUpdate(host, GURL::EmptyGURL());
+    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);
+
+    WaitForUpdateToFinish();
+  }
+
+  void UpgradeFetchManifestFailTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(service_.get(), GURL("http://failme"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    AppCache* cache = MakeCacheForGroup(1);
+    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());
+    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());
+    frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
+    frontend1->AddExpectedEvent(ids1, ERROR_EVENT);
+    MockFrontend::HostIds ids2(1, host2->host_id());
+    frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
+    frontend2->AddExpectedEvent(ids2, ERROR_EVENT);
+
+    WaitForUpdateToFinish();
+  }
+
+  void ManifestRedirectTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    URLRequest::RegisterProtocolFactory("http", RedirectFactory);
+
+    MakeService();
+    group_ = new AppCacheGroup(service_.get(), GURL("http://testme"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    MockFrontend* frontend = MakeMockFrontend();
+    AppCacheHost* host = MakeHost(1, frontend);
+    update->StartUpdate(host, GURL::EmptyGURL());
+    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"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    MockFrontend* frontend = MakeMockFrontend();
+    AppCacheHost* host = MakeHost(1, frontend);
+    update->StartUpdate(host, GURL::EmptyGURL());
+    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();
+  }
+
+  void ManifestNotFoundTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(
+        service_.get(), http_server_->TestServerPage("files/nosuchfile"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    AppCache* cache = MakeCacheForGroup(1);
+    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());
+    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"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    MockFrontend* frontend = MakeMockFrontend();
+    AppCacheHost* host = MakeHost(1, frontend);
+    update->StartUpdate(host, GURL::EmptyGURL());
+    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"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    MockFrontend* frontend = MakeMockFrontend();
+    AppCacheHost* host = MakeHost(1, frontend);
+    update->StartUpdate(host, GURL::EmptyGURL());
+    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();
+  }
+
+  void UpgradeNotModifiedTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(
+        service_.get(), http_server_->TestServerPage("files/notmodified"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    AppCache* cache = MakeCacheForGroup(1);
+    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());
+    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);
+    MockFrontend::HostIds ids2(1, host2->host_id());
+    frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
+    frontend2->AddExpectedEvent(ids2, NO_UPDATE_EVENT);
+
+    WaitForUpdateToFinish();
+  }
+
+  void UpgradeManifestDataUnchangedTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(
+        service_.get(), http_server_->TestServerPage("files/manifest1"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    AppCache* cache = MakeCacheForGroup(1);
+    MockFrontend* frontend1 = MakeMockFrontend();
+    MockFrontend* frontend2 = MakeMockFrontend();
+    AppCacheHost* host1 = MakeHost(1, frontend1);
+    AppCacheHost* host2 = MakeHost(2, frontend2);
+    host1->AssociateCache(cache);
+    host2->AssociateCache(cache);
+
+    // TODO(jennb): simulate this by mocking storage behavior instead
+    update->SimulateManifestChanged(false);  // unchanged
+
+    update->StartUpdate(NULL, GURL::EmptyGURL());
+    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);
+    MockFrontend::HostIds ids2(1, host2->host_id());
+    frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
+    frontend2->AddExpectedEvent(ids2, NO_UPDATE_EVENT);
+
+    WaitForUpdateToFinish();
+  }
+
+  void BasicCacheAttemptSuccessTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(
+      service_.get(), http_server_->TestServerPage("files/manifest1"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    MockFrontend* frontend = MakeMockFrontend();
+    AppCacheHost* host = MakeHost(1, frontend);
+    update->StartUpdate(host, GURL::EmptyGURL());
+    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);
+
+    WaitForUpdateToFinish();
+  }
+
+  void BasicUpgradeSuccessTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(
+        service_.get(), http_server_->TestServerPage("files/manifest1"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    AppCache* cache = MakeCacheForGroup(service_->NewCacheId());
+    MockFrontend* frontend1 = MakeMockFrontend();
+    MockFrontend* frontend2 = MakeMockFrontend();
+    AppCacheHost* host1 = MakeHost(1, frontend1);
+    AppCacheHost* host2 = MakeHost(2, frontend2);
+    host1->AssociateCache(cache);
+    host2->AssociateCache(cache);
+
+    // TODO(jennb): simulate this by mocking storage behavior instead
+    update->SimulateManifestChanged(true);  // changed
+
+    update->StartUpdate(NULL, GURL::EmptyGURL());
+    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;
+    MockFrontend::HostIds ids1(1, host1->host_id());
+    frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
+    frontend1->AddExpectedEvent(ids1, DOWNLOADING_EVENT);
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);
+    frontend1->AddExpectedEvent(ids1, UPDATE_READY_EVENT);
+    MockFrontend::HostIds ids2(1, host2->host_id());
+    frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
+    frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, UPDATE_READY_EVENT);
+
+    WaitForUpdateToFinish();
+  }
+
+  void UpgradeSuccessMergedTypesTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(service_.get(),
+        http_server_->TestServerPage("files/manifest-merged-types"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    AppCache* cache = MakeCacheForGroup(service_->NewCacheId());
+    MockFrontend* frontend1 = MakeMockFrontend();
+    MockFrontend* frontend2 = MakeMockFrontend();
+    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));
+
+    // TODO(jennb): simulate this by mocking storage behavior instead
+    update->SimulateManifestChanged(true);  // changed
+
+    update->StartUpdate(NULL, GURL::EmptyGURL());
+    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);
+    frontend1->AddExpectedEvent(ids1, DOWNLOADING_EVENT);
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);  // explicit1 (load)
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);  // explicit1 (fetch)
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);  // manifest
+    frontend1->AddExpectedEvent(ids1, UPDATE_READY_EVENT);
+    MockFrontend::HostIds ids2(1, host2->host_id());
+    frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
+    frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, UPDATE_READY_EVENT);
+
+    WaitForUpdateToFinish();
+  }
+
+  void CacheAttemptFailUrlFetchTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(
+      service_.get(), http_server_->TestServerPage("files/manifest-with-404"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    MockFrontend* frontend = MakeMockFrontend();
+    AppCacheHost* host = MakeHost(1, frontend);
+    update->StartUpdate(host, GURL::EmptyGURL());
+    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();
+  }
+
+  void UpgradeFailUrlFetchTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(
+      service_.get(), http_server_->TestServerPage("files/manifest-fb-404"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    AppCache* cache = MakeCacheForGroup(service_->NewCacheId());
+    MockFrontend* frontend1 = MakeMockFrontend();
+    MockFrontend* frontend2 = MakeMockFrontend();
+    AppCacheHost* host1 = MakeHost(1, frontend1);
+    AppCacheHost* host2 = MakeHost(2, frontend2);
+    host1->AssociateCache(cache);
+    host2->AssociateCache(cache);
+
+    // TODO(jennb): simulate this by mocking storage behavior instead
+    update->SimulateManifestChanged(true);  // changed
+
+    update->StartUpdate(NULL, GURL::EmptyGURL());
+    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);
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);
+    frontend1->AddExpectedEvent(ids1, ERROR_EVENT);
+    MockFrontend::HostIds ids2(1, host2->host_id());
+    frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
+    frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, ERROR_EVENT);
+
+    WaitForUpdateToFinish();
+  }
+
+  void UpgradeFailMasterUrlFetchTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(
+        service_.get(), http_server_->TestServerPage("files/manifest1"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    AppCache* cache = MakeCacheForGroup(service_->NewCacheId());
+    MockFrontend* frontend1 = MakeMockFrontend();
+    MockFrontend* frontend2 = MakeMockFrontend();
+    AppCacheHost* host1 = MakeHost(1, frontend1);
+    AppCacheHost* host2 = MakeHost(2, frontend2);
+    host1->AssociateCache(cache);
+    host2->AssociateCache(cache);
+
+    // Give the newest cache some master entries; one will fail with a 404.
+    cache->AddEntry(
+        http_server_->TestServerPage("files/notfound"),
+        AppCacheEntry(AppCacheEntry::MASTER));
+    cache->AddEntry(
+        http_server_->TestServerPage("files/explicit2"),
+        AppCacheEntry(AppCacheEntry::MASTER | AppCacheEntry::FOREIGN));
+    cache->AddEntry(
+        http_server_->TestServerPage("files/servererror"),
+        AppCacheEntry(AppCacheEntry::MASTER));
+
+    // TODO(jennb): simulate this by mocking storage behavior instead
+    update->SimulateManifestChanged(true);  // changed
+
+    update->StartUpdate(NULL, GURL::EmptyGURL());
+    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"),
+        AppCacheEntry(AppCacheEntry::MASTER)));  // foreign flag is dropped
+    expect_extra_entries_.insert(AppCache::EntryMap::value_type(
+        http_server_->TestServerPage("files/servererror"),
+        AppCacheEntry(AppCacheEntry::MASTER)));  // foreign flag is dropped
+    MockFrontend::HostIds ids1(1, host1->host_id());
+    frontend1->AddExpectedEvent(ids1, CHECKING_EVENT);
+    frontend1->AddExpectedEvent(ids1, DOWNLOADING_EVENT);
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);  // explicit1
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);  // fallback1a
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);  // notfound (load)
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);  // notfound (fetch)
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);  // explicit2 (load)
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);  // explicit2 (fetch)
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);  // servererror (load)
+    frontend1->AddExpectedEvent(ids1, PROGRESS_EVENT);  // servererror (fetch)
+    frontend1->AddExpectedEvent(ids1, UPDATE_READY_EVENT);
+    MockFrontend::HostIds ids2(1, host2->host_id());
+    frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
+    frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, PROGRESS_EVENT);
+    frontend2->AddExpectedEvent(ids2, UPDATE_READY_EVENT);
+
+    WaitForUpdateToFinish();
+  }
+
+  void EmptyManifestTest() {
+    ASSERT_EQ(MessageLoop::TYPE_IO, MessageLoop::current()->type());
+
+    MakeService();
+    group_ = new AppCacheGroup(
+        service_.get(), http_server_->TestServerPage("files/empty-manifest"));
+    AppCacheUpdateJob* update = new AppCacheUpdateJob(service_.get(), group_);
+    group_->update_job_ = update;
+
+    AppCache* cache = MakeCacheForGroup(service_->NewCacheId());
+    MockFrontend* frontend1 = MakeMockFrontend();
+    MockFrontend* frontend2 = MakeMockFrontend();
+    AppCacheHost* host1 = MakeHost(1, frontend1);
+    AppCacheHost* host2 = MakeHost(2, frontend2);
+    host1->AssociateCache(cache);
+    host2->AssociateCache(cache);
+
+    // TODO(jennb): simulate this by mocking storage behavior instead
+    update->SimulateManifestChanged(true);  // changed
+
+    update->StartUpdate(NULL, GURL::EmptyGURL());
+    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);
+    frontend1->AddExpectedEvent(ids1, DOWNLOADING_EVENT);
+    frontend1->AddExpectedEvent(ids1, UPDATE_READY_EVENT);
+    MockFrontend::HostIds ids2(1, host2->host_id());
+    frontend2->AddExpectedEvent(ids2, CHECKING_EVENT);
+    frontend2->AddExpectedEvent(ids2, DOWNLOADING_EVENT);
+    frontend2->AddExpectedEvent(ids2, UPDATE_READY_EVENT);
+
+    WaitForUpdateToFinish();
+  }
+
+  void WaitForUpdateToFinish() {
+    if (group_->update_status() == AppCacheGroup::IDLE)
+      UpdateFinished();
+    else
+      group_->AddObserver(this);
+  }
+
+  void OnUpdateComplete(AppCacheGroup* group) {
+    ASSERT_EQ(group_, group);
+
+    // Finish up outside of observer callback so that group can be deleted.
+    MessageLoop::current()->PostTask(FROM_HERE,
+        method_factory_.NewRunnableMethod(
+            &AppCacheUpdateJobTest::UpdateFinished));
+  }
+
+  void UpdateFinished() {
+    EXPECT_EQ(AppCacheGroup::IDLE, group_->update_status());
+    EXPECT_TRUE(group_->update_job() == NULL);
+    if (do_checks_after_update_finished_)
+      VerifyExpectations();
+
+    // Clean up everything that was created on the IO thread.
+    group_ = NULL;
+    STLDeleteContainerPointers(hosts_.begin(), hosts_.end());
+    STLDeleteContainerPointers(frontends_.begin(), frontends_.end());
+    service_.reset(NULL);
+    URLRequest::RegisterProtocolFactory("http", NULL);
+
+    event_->Signal();
+  }
+
+  void MakeService() {
+    service_.reset(new AppCacheService());
+    request_context_ = new TestURLRequestContext();
+    service_->set_request_context(request_context_);
+  }
+
+  AppCache* MakeCacheForGroup(int64 cache_id) {
+    AppCache* cache = new AppCache(service_.get(), cache_id);
+    cache->set_complete(true);
+    cache->set_update_time(base::TimeTicks::Now());
+    cache->set_owning_group(group_);
+    group_->AddCache(cache);
+    return cache;
+  }
+
+  AppCacheHost* MakeHost(int host_id, AppCacheFrontend* frontend) {
+    AppCacheHost* host = new AppCacheHost(host_id, frontend, service_.get());
+    hosts_.push_back(host);
+    return host;
+  }
+
+  MockFrontend* MakeMockFrontend() {
+    MockFrontend* frontend = new MockFrontend();
+    frontends_.push_back(frontend);
+    return frontend;
+  }
+
+  // Verifies conditions about the group and notifications after an update
+  // has finished. Cannot verify update job internals as update is deleted.
+  void VerifyExpectations() {
+    EXPECT_EQ(expect_group_obsolete_, group_->is_obsolete());
+
+    if (expect_group_has_cache_) {
+      EXPECT_TRUE(group_->newest_complete_cache() != NULL);
+      if (expect_old_cache_) {
+        EXPECT_NE(expect_old_cache_, group_->newest_complete_cache());
+        EXPECT_TRUE(group_->old_caches().end() !=
+            std::find(group_->old_caches().begin(),
+                      group_->old_caches().end(), expect_old_cache_));
+      }
+      if (expect_newest_cache_)
+        EXPECT_EQ(expect_newest_cache_, group_->newest_complete_cache());
+      switch (tested_manifest_) {
+        case MANIFEST1:
+          VerifyManifest1(group_->newest_complete_cache());
+          break;
+        case MANIFEST_MERGED_TYPES:
+          VerifyManifestMergedTypes(group_->newest_complete_cache());
+          break;
+        case EMPTY_MANIFEST:
+          VerifyEmptyManifest(group_->newest_complete_cache());
+          break;
+        case NONE:
+        default:
+          break;
+      }
+    } else {
+      EXPECT_TRUE(group_->newest_complete_cache() == NULL);
+    }
+
+    // Check expected events.
+    for (size_t i = 0; i < frontends_.size(); ++i) {
+      MockFrontend* frontend = frontends_[i];
+
+      MockFrontend::RaisedEvents& expected_events = frontend->expected_events_;
+      MockFrontend::RaisedEvents& actual_events = frontend->raised_events_;
+      EXPECT_EQ(expected_events.size(), actual_events.size());
+
+      // Check each expected event.
+      for (size_t j = 0;
+           j < expected_events.size() && j < actual_events.size(); ++j) {
+        EXPECT_EQ(expected_events[j].second, actual_events[j].second);
+
+        MockFrontend::HostIds& expected_ids = expected_events[j].first;
+        MockFrontend::HostIds& actual_ids = actual_events[j].first;
+        EXPECT_EQ(expected_ids.size(), actual_ids.size());
+
+        for (size_t k = 0; k < expected_ids.size(); ++k) {
+          int id = expected_ids[k];
+          EXPECT_TRUE(std::find(actual_ids.begin(), actual_ids.end(), id) !=
+              actual_ids.end());
+        }
+      }
+    }
+  }
+
+  void VerifyManifest1(AppCache* cache) {
+    ASSERT_TRUE(cache != NULL);
+    EXPECT_EQ(group_, cache->owning_group());
+    EXPECT_TRUE(cache->is_complete());
+
+    size_t expected = 3 + expect_extra_entries_.size();
+    EXPECT_EQ(expected, cache->entries().size());
+    AppCacheEntry* entry =
+        cache->GetEntry(http_server_->TestServerPage("files/manifest1"));
+    ASSERT_TRUE(entry);
+    EXPECT_EQ(AppCacheEntry::MANIFEST, entry->types());
+    entry = cache->GetEntry(http_server_->TestServerPage("files/explicit1"));
+    ASSERT_TRUE(entry);
+    EXPECT_EQ(AppCacheEntry::EXPLICIT, entry->types());
+    entry = cache->GetEntry(
+        http_server_->TestServerPage("files/fallback1a"));
+    ASSERT_TRUE(entry);
+    EXPECT_EQ(AppCacheEntry::FALLBACK, entry->types());
+
+    for (AppCache::EntryMap::iterator i = expect_extra_entries_.begin();
+         i != expect_extra_entries_.end(); ++i) {
+      entry = cache->GetEntry(i->first);
+      ASSERT_TRUE(entry);
+      EXPECT_EQ(i->second.types(), entry->types());
+      // TODO(jennb): if copied, check storage id in entry is as expected
+    }
+
+    expected = 1;
+    EXPECT_EQ(expected, cache->fallback_namespaces_.size());
+    EXPECT_TRUE(cache->fallback_namespaces_.end() !=
+        std::find(cache->fallback_namespaces_.begin(),
+                  cache->fallback_namespaces_.end(),
+                  FallbackNamespace(
+                      http_server_->TestServerPage("files/fallback1"),
+                      http_server_->TestServerPage("files/fallback1a"))));
+
+    EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
+    EXPECT_TRUE(cache->online_whitelist_all_);
+
+    EXPECT_TRUE(cache->update_time_ > base::TimeTicks());
+  }
+
+  void VerifyManifestMergedTypes(AppCache* cache) {
+    ASSERT_TRUE(cache != NULL);
+    EXPECT_EQ(group_, cache->owning_group());
+    EXPECT_TRUE(cache->is_complete());
+
+    size_t expected = 2;
+    EXPECT_EQ(expected, cache->entries().size());
+    AppCacheEntry* entry = cache->GetEntry(
+        http_server_->TestServerPage("files/manifest-merged-types"));
+    ASSERT_TRUE(entry);
+    EXPECT_EQ(AppCacheEntry::EXPLICIT | AppCacheEntry::MANIFEST,
+              entry->types());
+    entry = cache->GetEntry(http_server_->TestServerPage("files/explicit1"));
+    ASSERT_TRUE(entry);
+    EXPECT_EQ(AppCacheEntry::EXPLICIT | AppCacheEntry::FALLBACK |
+        AppCacheEntry::MASTER, entry->types());
+
+    expected = 1;
+    EXPECT_EQ(expected, cache->fallback_namespaces_.size());
+    EXPECT_TRUE(cache->fallback_namespaces_.end() !=
+        std::find(cache->fallback_namespaces_.begin(),
+                  cache->fallback_namespaces_.end(),
+                  FallbackNamespace(
+                      http_server_->TestServerPage("files/fallback1"),
+                      http_server_->TestServerPage("files/explicit1"))));
+
+    EXPECT_EQ(expected, cache->online_whitelist_namespaces_.size());
+    EXPECT_TRUE(cache->online_whitelist_namespaces_.end() !=
+        std::find(cache->online_whitelist_namespaces_.begin(),
+                  cache->online_whitelist_namespaces_.end(),
+                  http_server_->TestServerPage("files/online1")));
+    EXPECT_FALSE(cache->online_whitelist_all_);
+
+    EXPECT_TRUE(cache->update_time_ > base::TimeTicks());
+  }
+
+  void VerifyEmptyManifest(AppCache* cache) {
+    ASSERT_TRUE(cache!= NULL);
+    EXPECT_EQ(group_, cache->owning_group());
+    EXPECT_TRUE(cache->is_complete());
+
+    size_t expected = 1;
+    EXPECT_EQ(expected, cache->entries().size());
+    AppCacheEntry* entry = cache->GetEntry(
+        http_server_->TestServerPage("files/empty-manifest"));
+    ASSERT_TRUE(entry);
+    EXPECT_EQ(AppCacheEntry::MANIFEST, entry->types());
+
+    EXPECT_TRUE(cache->fallback_namespaces_.empty());
+    EXPECT_TRUE(cache->online_whitelist_namespaces_.empty());
+    EXPECT_FALSE(cache->online_whitelist_all_);
+
+    EXPECT_TRUE(cache->update_time_ > base::TimeTicks());
+  }
+
+ private:
+  // Various manifest files used in this test.
+  enum TestedManifest {
+    NONE,
+    MANIFEST1,
+    MANIFEST_MERGED_TYPES,
+    EMPTY_MANIFEST,
+  };
+
+  static scoped_ptr<base::Thread> io_thread_;
+  static scoped_refptr<HTTPTestServer> http_server_;
+
+  ScopedRunnableMethodFactory<AppCacheUpdateJobTest> method_factory_;
+  scoped_ptr<AppCacheService> service_;
+  scoped_refptr<TestURLRequestContext> request_context_;
+  scoped_refptr<AppCacheGroup> group_;
+  scoped_ptr<base::WaitableEvent> event_;
+
+  // Hosts used by an async test that need to live until update job finishes.
+  // Otherwise, test can put host on the stack instead of here.
+  std::vector<AppCacheHost*> hosts_;
+
+  // Flag indicating if test cares to verify the update after update finishes.
+  bool do_checks_after_update_finished_;
+  bool expect_group_obsolete_;
+  bool expect_group_has_cache_;
+  AppCache* expect_old_cache_;
+  AppCache* expect_newest_cache_;
+  std::vector<MockFrontend*> frontends_;  // to check expected events
+  TestedManifest tested_manifest_;
+  AppCache::EntryMap expect_extra_entries_;
+};
+
+// static
+scoped_ptr<base::Thread> AppCacheUpdateJobTest::io_thread_;
+scoped_refptr<HTTPTestServer> AppCacheUpdateJobTest::http_server_;
+
+TEST_F(AppCacheUpdateJobTest, AlreadyChecking) {
+  AppCacheService service;
+  scoped_refptr<AppCacheGroup> group =
+      new AppCacheGroup(&service, GURL("http://manifesturl.com"));
+
+  AppCacheUpdateJob update(&service, group);
+
+  // Pretend group is in checking state.
+  group->update_job_ = &update;
+  group->update_status_ = AppCacheGroup::CHECKING;
+
+  update.StartUpdate(NULL, GURL::EmptyGURL());
+  EXPECT_EQ(AppCacheGroup::CHECKING, group->update_status());
+
+  MockFrontend mock_frontend;
+  AppCacheHost host(1, &mock_frontend, &service);
+  update.StartUpdate(&host, GURL::EmptyGURL());
+
+  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) {
+  AppCacheService service;
+  scoped_refptr<AppCacheGroup> group =
+      new AppCacheGroup(&service, GURL("http://manifesturl.com"));
+
+  AppCacheUpdateJob update(&service, group);
+
+  // Pretend group is in downloading state.
+  group->update_job_ = &update;
+  group->update_status_ = AppCacheGroup::DOWNLOADING;
+
+  update.StartUpdate(NULL, GURL::EmptyGURL());
+  EXPECT_EQ(AppCacheGroup::DOWNLOADING, group->update_status());
+
+  MockFrontend mock_frontend;
+  AppCacheHost host(1, &mock_frontend, &service);
+  update.StartUpdate(&host, GURL::EmptyGURL());
+
+  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());
+  EXPECT_EQ(host.host_id(), events[1].first[0]);
+  EXPECT_EQ(appcache::DOWNLOADING_EVENT, events[1].second);
+
+  EXPECT_EQ(AppCacheGroup::DOWNLOADING, group->update_status());
+}
+
+TEST_F(AppCacheUpdateJobTest, StartCacheAttempt) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::StartCacheAttemptTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, StartUpgradeAttempt) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::StartUpgradeAttemptTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, CacheAttemptFetchManifestFail) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::CacheAttemptFetchManifestFailTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, UpgradeFetchManifestFail) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeFetchManifestFailTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, ManifestRedirect) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::ManifestRedirectTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, ManifestWrongMimeType) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::ManifestWrongMimeTypeTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, ManifestNotFound) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::ManifestNotFoundTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, ManifestGone) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::ManifestGoneTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, CacheAttemptNotModified) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::CacheAttemptNotModifiedTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, UpgradeNotModified) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeNotModifiedTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, UpgradeManifestDataUnchanged) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeManifestDataUnchangedTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, BasicCacheAttemptSuccess) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::BasicCacheAttemptSuccessTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, BasicUpgradeSuccess) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::BasicUpgradeSuccessTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, UpgradeSuccessMergedTypes) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeSuccessMergedTypesTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, CacheAttemptFailUrlFetch) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::CacheAttemptFailUrlFetchTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, UpgradeFailUrlFetch) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeFailUrlFetchTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, UpgradeFailMasterUrlFetch) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::UpgradeFailMasterUrlFetchTest);
+}
+
+TEST_F(AppCacheUpdateJobTest, EmptyManifest) {
+  RunTestOnIOThread(&AppCacheUpdateJobTest::EmptyManifestTest);
+}
+
+}  // namespace appcache