When deleting storage through the cookies tree model, also update its cache

chrome/browser/browsing_data_file_system_helper_unittest.cc

 // Copyright (c) 2011 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/utf_string_conversions.h"
 #include "chrome/browser/browsing_data_file_system_helper.h"
 #include "chrome/test/base/testing_browser_process_test.h"
 #include "chrome/test/base/testing_profile.h"
@@ skipping 17 matching lines @@
 const char kTestOrigin3[] = "http://host3:3/";
 
 const GURL kOrigin1(kTestOrigin1);
 const GURL kOrigin2(kTestOrigin2);
 const GURL kOrigin3(kTestOrigin3);
 
 // TODO(mkwst): Update this size once the discussion in http://crbug.com/86114
 // is concluded.
 const int kEmptyFileSystemSize = 0;
 
-typedef std::vector<BrowsingDataFileSystemHelper::FileSystemInfo>
-    FileSystemInfoVector;
-typedef scoped_ptr<FileSystemInfoVector> ScopedFileSystemInfoVector;
+typedef std::list<BrowsingDataFileSystemHelper::FileSystemInfo>
+    FileSystemInfoList;
+typedef scoped_ptr<FileSystemInfoList> ScopedFileSystemInfoList;
 
 // The FileSystem APIs are all asynchronous; this testing class wraps up the
 // boilerplate code necessary to deal with waiting for responses. In a nutshell,
 // any async call whose response we want to test ought to be followed by a call
 // to BlockUntilNotified(), which will (shockingly!) block until Notify() is
 // called. For this to work, you'll need to ensure that each async call is
 // implemented as a class method that that calls Notify() at an appropriate
 // point.
 class BrowsingDataFileSystemHelperTest : public TestingBrowserProcessTest {
  public:
@@ skipping 39 matching lines @@
     sandbox_->ValidateFileSystemRootAndGetURL(
         origin, type, false, NewCallback(this,
             &BrowsingDataFileSystemHelperTest::CallbackFindFileSystemPath));
     BlockUntilNotified();
     return found_file_system_;
   }
 
   // Callback that should be executed in response to StartFetching(), and stores
   // found file systems locally so that they are available via GetFileSystems().
   void CallbackStartFetching(
-      const std::vector<BrowsingDataFileSystemHelper::FileSystemInfo>&
+      const std::list<BrowsingDataFileSystemHelper::FileSystemInfo>&
           file_system_info_list) {
     file_system_info_list_.reset(
-        new std::vector<BrowsingDataFileSystemHelper::FileSystemInfo>(
+        new std::list<BrowsingDataFileSystemHelper::FileSystemInfo>(
             file_system_info_list));
     Notify();
   }
 
   // Calls StartFetching() on the test's BrowsingDataFileSystemHelper
   // object, then blocks until the callback is executed.
   void FetchFileSystems() {
     helper_->StartFetching(NewCallback(this,
         &BrowsingDataFileSystemHelperTest::CallbackStartFetching));
     BlockUntilNotified();
@@ skipping 30 matching lines @@
   // specified origin.
   void CreateDirectoryForOriginAndType(const GURL& origin,
                                        fileapi::FileSystemType type) {
     FilePath target = sandbox_->ValidateFileSystemRootAndGetPathOnFileThread(
         origin, type, FilePath(), true);
     EXPECT_TRUE(file_util::DirectoryExists(target));
   }
 
   // Returns a list of the FileSystemInfo objects gathered in the most recent
   // call to StartFetching().
-  FileSystemInfoVector* GetFileSystems() {
+  FileSystemInfoList* GetFileSystems() {
     return file_system_info_list_.get();
   }
 
 
   // Temporary storage to pass information back from callbacks.
   bool found_file_system_;
-  ScopedFileSystemInfoVector file_system_info_list_;
+  ScopedFileSystemInfoList file_system_info_list_;
 
   scoped_refptr<BrowsingDataFileSystemHelper> helper_;
   scoped_refptr<CannedBrowsingDataFileSystemHelper> canned_helper_;
 
  private:
   // message_loop_, as well as all the threads associated with it must be
   // defined before profile_ to prevent explosions. The threads also must be
   // defined in the order they're listed here. Oh how I love C++.
   MessageLoopForUI message_loop_;
   BrowserThread ui_thread_;
@@ skipping 11 matching lines @@
 // system data, and that each file system returned contains the expected data.
 TEST_F(BrowsingDataFileSystemHelperTest, FetchData) {
   PopulateTestFileSystemData();
 
   FetchFileSystems();
 
   EXPECT_EQ(3UL, file_system_info_list_->size());
 
   // Order is arbitrary, verify all three origins.
   bool test_hosts_found[3] = {false, false, false};
-  for (size_t i = 0; i < file_system_info_list_->size(); i++) {
-    BrowsingDataFileSystemHelper::FileSystemInfo info =
-        file_system_info_list_->at(i);
-    if (info.origin == kOrigin1) {
+  for (std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator info =
+       file_system_info_list_->begin(); info != file_system_info_list_->end();
+       ++info) {
+    if (info->origin == kOrigin1) {
         EXPECT_FALSE(test_hosts_found[0]);
         test_hosts_found[0] = true;
-        EXPECT_FALSE(info.has_persistent);
-        EXPECT_TRUE(info.has_temporary);
-        EXPECT_EQ(0, info.usage_persistent);
-        EXPECT_EQ(kEmptyFileSystemSize, info.usage_temporary);
-    } else if (info.origin == kOrigin2) {
+        EXPECT_FALSE(info->has_persistent);
+        EXPECT_TRUE(info->has_temporary);
+        EXPECT_EQ(0, info->usage_persistent);
+        EXPECT_EQ(kEmptyFileSystemSize, info->usage_temporary);
+    } else if (info->origin == kOrigin2) {
         EXPECT_FALSE(test_hosts_found[1]);
         test_hosts_found[1] = true;
-        EXPECT_TRUE(info.has_persistent);
-        EXPECT_FALSE(info.has_temporary);
-        EXPECT_EQ(kEmptyFileSystemSize, info.usage_persistent);
-        EXPECT_EQ(0, info.usage_temporary);
-    } else if (info.origin == kOrigin3) {
+        EXPECT_TRUE(info->has_persistent);
+        EXPECT_FALSE(info->has_temporary);
+        EXPECT_EQ(kEmptyFileSystemSize, info->usage_persistent);
+        EXPECT_EQ(0, info->usage_temporary);
+    } else if (info->origin == kOrigin3) {
         EXPECT_FALSE(test_hosts_found[2]);
         test_hosts_found[2] = true;
-        EXPECT_TRUE(info.has_persistent);
-        EXPECT_TRUE(info.has_temporary);
-        EXPECT_EQ(kEmptyFileSystemSize, info.usage_persistent);
-        EXPECT_EQ(kEmptyFileSystemSize, info.usage_temporary);
+        EXPECT_TRUE(info->has_persistent);
+        EXPECT_TRUE(info->has_temporary);
+        EXPECT_EQ(kEmptyFileSystemSize, info->usage_persistent);
+        EXPECT_EQ(kEmptyFileSystemSize, info->usage_temporary);
     } else {
-        ADD_FAILURE() << info.origin.spec() << " isn't an origin we added.";
+        ADD_FAILURE() << info->origin.spec() << " isn't an origin we added.";
     }
   }
   for (size_t i = 0; i < arraysize(test_hosts_found); i++) {
     EXPECT_TRUE(test_hosts_found[i]);
   }
 }
 
 // Verifies that the BrowsingDataFileSystemHelper correctly deletes file
 // systems via DeleteFileSystemOrigin().
 TEST_F(BrowsingDataFileSystemHelperTest, DeleteData) {
   PopulateTestFileSystemData();
 
   helper_->DeleteFileSystemOrigin(kOrigin1);
   helper_->DeleteFileSystemOrigin(kOrigin2);
 
   FetchFileSystems();
 
   EXPECT_EQ(1UL, file_system_info_list_->size());
   BrowsingDataFileSystemHelper::FileSystemInfo info =
-      file_system_info_list_->at(0);
+      *(file_system_info_list_->begin());
   EXPECT_EQ(kOrigin3, info.origin);
   EXPECT_TRUE(info.has_persistent);
   EXPECT_TRUE(info.has_temporary);
   EXPECT_EQ(kEmptyFileSystemSize, info.usage_persistent);
   EXPECT_EQ(kEmptyFileSystemSize, info.usage_temporary);
 }
 
 // Verifies that the CannedBrowsingDataFileSystemHelper correctly reports
 // whether or not it currently contains file systems.
 TEST_F(BrowsingDataFileSystemHelperTest, Empty) {
   ASSERT_TRUE(canned_helper_->empty());
   canned_helper_->AddFileSystem(kOrigin1, kTemporary, 0);
   ASSERT_FALSE(canned_helper_->empty());
   canned_helper_->Reset();
   ASSERT_TRUE(canned_helper_->empty());
 }
 
 // Verifies that AddFileSystem correctly adds file systems, and that both
 // the type and usage metadata are reported as provided.
 TEST_F(BrowsingDataFileSystemHelperTest, CannedAddFileSystem) {
   canned_helper_->AddFileSystem(kOrigin1, kPersistent, 200);
   canned_helper_->AddFileSystem(kOrigin2, kTemporary, 100);
 
   FetchCannedFileSystems();
 
   EXPECT_EQ(2U, file_system_info_list_->size());
-  EXPECT_EQ(kOrigin1, file_system_info_list_->at(0).origin);
-  EXPECT_TRUE(file_system_info_list_->at(0).has_persistent);
-  EXPECT_FALSE(file_system_info_list_->at(0).has_temporary);
-  EXPECT_EQ(200, file_system_info_list_->at(0).usage_persistent);
-  EXPECT_EQ(0, file_system_info_list_->at(0).usage_temporary);
-  EXPECT_EQ(kOrigin2, file_system_info_list_->at(1).origin);
-  EXPECT_FALSE(file_system_info_list_->at(1).has_persistent);
-  EXPECT_TRUE(file_system_info_list_->at(1).has_temporary);
-  EXPECT_EQ(0, file_system_info_list_->at(1).usage_persistent);
-  EXPECT_EQ(100, file_system_info_list_->at(1).usage_temporary);
+  std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator info =
+      file_system_info_list_->begin();
+  EXPECT_EQ(kOrigin1, info->origin);
+  EXPECT_TRUE(info->has_persistent);
+  EXPECT_FALSE(info->has_temporary);
+  EXPECT_EQ(200, info->usage_persistent);
+  EXPECT_EQ(0, info->usage_temporary);
+
+  info++;
+  EXPECT_EQ(kOrigin2, info->origin);
+  EXPECT_FALSE(info->has_persistent);
+  EXPECT_TRUE(info->has_temporary);
+  EXPECT_EQ(0, info->usage_persistent);
+  EXPECT_EQ(100, info->usage_temporary);
 }
 
 }  // namespace