Fix http/tests/appcache/foreign-fallback.html

webkit/appcache/mock_appcache_storage_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 "base/message_loop.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/appcache/appcache.h"
 #include "webkit/appcache/appcache_group.h"
 #include "webkit/appcache/appcache_response.h"
 #include "webkit/appcache/appcache_storage.h"
@@ skipping 26 matching lines @@
       stored_group_ = group;
       stored_group_success_ = success;
     }
 
     void OnGroupMadeObsolete(AppCacheGroup* group, bool success) {
       obsoleted_group_ = group;
       obsoleted_success_ = success;
     }
 
     void OnMainResponseFound(const GURL& url, const AppCacheEntry& entry,
+                             const GURL& fallback_url,
                              const AppCacheEntry& fallback_entry,
                              int64 cache_id, const GURL& manifest_url,
                              bool was_blocked_by_policy) {
       found_url_ = url;
       found_entry_ = entry;
+      found_fallback_url_ = fallback_url;
       found_fallback_entry_ = fallback_entry;
       found_cache_id_ = cache_id;
       found_manifest_url_ = manifest_url;
     }
 
     scoped_refptr<AppCache> loaded_cache_;
     int64 loaded_cache_id_;
     scoped_refptr<AppCacheGroup> loaded_group_;
     GURL loaded_manifest_url_;
     scoped_refptr<AppCacheGroup> stored_group_;
     bool stored_group_success_;
     scoped_refptr<AppCacheGroup> obsoleted_group_;
     bool obsoleted_success_;
     GURL found_url_;
     AppCacheEntry found_entry_;
+    GURL found_fallback_url_;
     AppCacheEntry found_fallback_entry_;
     int64 found_cache_id_;
     GURL found_manifest_url_;
   };
 };
 
 
 TEST_F(MockAppCacheStorageTest, LoadCache_Miss) {
   // Attempt to load a cache that doesn't exist. Should
   // complete asyncly.
@@ skipping 315 matching lines @@
   GURL url("http://blah/some_url");
   EXPECT_NE(url, delegate.found_url_);
   storage->FindResponseForMainRequest(url, &delegate);
   EXPECT_NE(url, delegate.found_url_);
   MessageLoop::current()->RunAllPending();  // Do async task execution.
   EXPECT_EQ(url, delegate.found_url_);
   EXPECT_TRUE(delegate.found_manifest_url_.is_empty());
   EXPECT_EQ(kNoCacheId, delegate.found_cache_id_);
   EXPECT_EQ(kNoResponseId, delegate.found_entry_.response_id());
   EXPECT_EQ(kNoResponseId, delegate.found_fallback_entry_.response_id());
+  EXPECT_TRUE(delegate.found_fallback_url_.is_empty());
   EXPECT_EQ(0, delegate.found_entry_.types());
   EXPECT_EQ(0, delegate.found_fallback_entry_.types());
 }
 
 TEST_F(MockAppCacheStorageTest, BasicFindMainResponse) {
   // Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
@@ skipping 71 matching lines @@
   MockStorageDelegate delegate;
   EXPECT_NE(kTestUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kTestUrl, &delegate);
   EXPECT_NE(kTestUrl, delegate.found_url_);
   MessageLoop::current()->RunAllPending();  // Do async task execution.
   EXPECT_EQ(kTestUrl, delegate.found_url_);
   EXPECT_EQ(kManifestUrl, delegate.found_manifest_url_);
   EXPECT_EQ(kCacheId, delegate.found_cache_id_);
   EXPECT_FALSE(delegate.found_entry_.has_response_id());
   EXPECT_EQ(kResponseId2, delegate.found_fallback_entry_.response_id());
+  EXPECT_EQ(kFallbackEntryUrl2, delegate.found_fallback_url_);
   EXPECT_TRUE(delegate.found_fallback_entry_.IsFallback());
 }
 
 TEST_F(MockAppCacheStorageTest, FindMainResponseWithMultipleCandidates) {
   // Should complete asyncly.
   MockAppCacheService service;
   MockAppCacheStorage* storage =
       reinterpret_cast<MockAppCacheStorage*>(service.storage());
 
   // Setup some preconditions. Create 2 complete caches with an entry
@@ skipping 82 matching lines @@
   // We should not find anything for the foreign entry.
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kEntryUrl, &delegate);
   EXPECT_NE(kEntryUrl, delegate.found_url_);
   MessageLoop::current()->RunAllPending();  // Do async task execution.
   EXPECT_EQ(kEntryUrl, delegate.found_url_);
   EXPECT_TRUE(delegate.found_manifest_url_.is_empty());
   EXPECT_EQ(kNoCacheId, delegate.found_cache_id_);
   EXPECT_EQ(kNoResponseId, delegate.found_entry_.response_id());
   EXPECT_EQ(kNoResponseId, delegate.found_fallback_entry_.response_id());
+  EXPECT_TRUE(delegate.found_fallback_url_.is_empty());
   EXPECT_EQ(0, delegate.found_entry_.types());
   EXPECT_EQ(0, delegate.found_fallback_entry_.types());
 
   // We should not find anything for the online namespace.
   EXPECT_NE(kOnlineNamespaceUrl, delegate.found_url_);
   storage->FindResponseForMainRequest(kOnlineNamespaceUrl, &delegate);
   EXPECT_NE(kOnlineNamespaceUrl, delegate.found_url_);
   MessageLoop::current()->RunAllPending();  // Do async task execution.
   EXPECT_EQ(kOnlineNamespaceUrl, delegate.found_url_);
   EXPECT_TRUE(delegate.found_manifest_url_.is_empty());
   EXPECT_EQ(kNoCacheId, delegate.found_cache_id_);
   EXPECT_EQ(kNoResponseId, delegate.found_entry_.response_id());
   EXPECT_EQ(kNoResponseId, delegate.found_fallback_entry_.response_id());
+  EXPECT_TRUE(delegate.found_fallback_url_.is_empty());
   EXPECT_EQ(0, delegate.found_entry_.types());
   EXPECT_EQ(0, delegate.found_fallback_entry_.types());
 }
 
 }  // namespace appcache