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

chrome/browser/browsing_data_indexed_db_helper.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 "chrome/browser/browsing_data_indexed_db_helper.h"
 
 #include "base/callback_old.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/profiles/profile.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCString.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebSecurityOrigin.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebString.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/in_process_webkit/webkit_context.h"
 #include "webkit/glue/webkit_glue.h"
 
 using WebKit::WebSecurityOrigin;
 
 namespace {
 
 class BrowsingDataIndexedDBHelperImpl : public BrowsingDataIndexedDBHelper {
  public:
   explicit BrowsingDataIndexedDBHelperImpl(Profile* profile);
 
   virtual void StartFetching(
-      Callback1<const std::vector<IndexedDBInfo>& >::Type* callback);
+      Callback1<const std::list<IndexedDBInfo>& >::Type* callback);
   virtual void CancelNotification();
   virtual void DeleteIndexedDBFile(const FilePath& file_path);
 
  private:
   virtual ~BrowsingDataIndexedDBHelperImpl();
 
   // Enumerates all indexed database files in the WEBKIT thread.
   void FetchIndexedDBInfoInWebKitThread();
   // Notifies the completion callback in the UI thread.
   void NotifyInUIThread();
   // Delete a single indexed database file in the WEBKIT thread.
   void DeleteIndexedDBFileInWebKitThread(const FilePath& file_path);
 
   Profile* profile_;
 
   // This only mutates in the WEBKIT thread.
-  std::vector<IndexedDBInfo> indexed_db_info_;
+  std::list<IndexedDBInfo> indexed_db_info_;
 
   // This only mutates on the UI thread.
-  scoped_ptr<Callback1<const std::vector<IndexedDBInfo>& >::Type >
+  scoped_ptr<Callback1<const std::list<IndexedDBInfo>& >::Type >
       completion_callback_;
   // Indicates whether or not we're currently fetching information:
   // it's true when StartFetching() is called in the UI thread, and it's reset
   // after we notified the callback in the UI thread.
   // This only mutates on the UI thread.
   bool is_fetching_;
 
   DISALLOW_COPY_AND_ASSIGN(BrowsingDataIndexedDBHelperImpl);
 };
 
 BrowsingDataIndexedDBHelperImpl::BrowsingDataIndexedDBHelperImpl(
     Profile* profile)
     : profile_(profile),
       completion_callback_(NULL),
       is_fetching_(false) {
   DCHECK(profile_);
 }
 
 BrowsingDataIndexedDBHelperImpl::~BrowsingDataIndexedDBHelperImpl() {
 }
 
 void BrowsingDataIndexedDBHelperImpl::StartFetching(
-    Callback1<const std::vector<IndexedDBInfo>& >::Type* callback) {
+    Callback1<const std::list<IndexedDBInfo>& >::Type* callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!is_fetching_);
   DCHECK(callback);
   is_fetching_ = true;
   completion_callback_.reset(callback);
   BrowserThread::PostTask(
       BrowserThread::WEBKIT, FROM_HERE,
       NewRunnableMethod(
           this,
           &BrowsingDataIndexedDBHelperImpl::FetchIndexedDBInfoInWebKitThread));
@@ skipping 147 matching lines @@
   indexed_db_info_.clear();
   pending_indexed_db_info_.clear();
 }
 
 bool CannedBrowsingDataIndexedDBHelper::empty() const {
   base::AutoLock auto_lock(lock_);
   return indexed_db_info_.empty() && pending_indexed_db_info_.empty();
 }
 
 void CannedBrowsingDataIndexedDBHelper::StartFetching(
-    Callback1<const std::vector<IndexedDBInfo>& >::Type* callback) {
+    Callback1<const std::list<IndexedDBInfo>& >::Type* callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!is_fetching_);
   DCHECK(callback);
   is_fetching_ = true;
   completion_callback_.reset(callback);
   BrowserThread::PostTask(BrowserThread::WEBKIT, FROM_HERE, NewRunnableMethod(
       this,
       &CannedBrowsingDataIndexedDBHelper::ConvertPendingInfoInWebKitThread));
 }
 
 CannedBrowsingDataIndexedDBHelper::~CannedBrowsingDataIndexedDBHelper() {}
 
 void CannedBrowsingDataIndexedDBHelper::ConvertPendingInfoInWebKitThread() {
   base::AutoLock auto_lock(lock_);
-  for (std::vector<PendingIndexedDBInfo>::const_iterator
+  for (std::list<PendingIndexedDBInfo>::const_iterator
        info = pending_indexed_db_info_.begin();
        info != pending_indexed_db_info_.end(); ++info) {
     WebSecurityOrigin web_security_origin =
         WebSecurityOrigin::createFromString(
             UTF8ToUTF16(info->origin.spec()));
     std::string security_origin(web_security_origin.toString().utf8());
 
     bool duplicate = false;
-    for (std::vector<IndexedDBInfo>::iterator
+    for (std::list<IndexedDBInfo>::iterator
          indexed_db = indexed_db_info_.begin();
          indexed_db != indexed_db_info_.end(); ++indexed_db) {
       if (indexed_db->origin == security_origin) {
         duplicate = true;
         break;
       }
     }
     if (duplicate)
       continue;
 
@@ skipping 25 matching lines @@
     completion_callback_->Run(indexed_db_info_);
     completion_callback_.reset();
   }
   is_fetching_ = false;
 }
 
 void CannedBrowsingDataIndexedDBHelper::CancelNotification() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   completion_callback_.reset();
 }