Creat BrowsingDataCookieHelper and CannedBrowsingDataCookieHelper for logging cookies at UI thread.

chrome/browser/cookies_tree_model.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/cookies_tree_model.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
+#include "base/bind.h"
 #include "base/callback.h"
 #include "base/memory/linked_ptr.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
+#include "chrome/browser/browsing_data_cookie_helper.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "content/browser/in_process_webkit/webkit_context.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/registry_controlled_domain.h"
 #include "net/url_request/url_request_context.h"
 #include "third_party/skia/include/core/SkBitmap.h"
@@ skipping 30 matching lines @@
 CookieTreeCookieNode::~CookieTreeCookieNode() {}
 
 void CookieTreeCookieNode::DeleteStoredObjects() {
   // notify CookieMonster that we should delete this cookie
   // We have stored a copy of all the cookies in the model, and our model is
   // never re-calculated. Thus, we just need to delete the nodes from our
   // model, and tell CookieMonster to delete the cookies. We can keep the
   // vector storing the cookies in-tact and not delete from there (that would
   // invalidate our pointers), and the fact that it contains semi out-of-date
   // data is not problematic as we don't re-build the model based on that.
-  GetModel()->cookie_monster_->DeleteCanonicalCookie(*cookie_);
+  GetModel()->cookie_helper_->DeleteCookie(*cookie_);
 }
 
 CookieTreeNode::DetailedInfo CookieTreeCookieNode::GetDetailedInfo() const {
   return DetailedInfo(parent()->parent()->GetTitle(),
                       DetailedInfo::TYPE_COOKIE,
                       cookie_, NULL, NULL, NULL, NULL, NULL, NULL);
 }
 
 namespace {
 // comparison functor, for use in CookieTreeRootNode
@@ skipping 468 matching lines @@
                   children().end(),
                   new_child,
                   NodeTitleComparator());
   GetModel()->Add(this, new_child, iter - children().begin());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // CookiesTreeModel, public:
 
 CookiesTreeModel::CookiesTreeModel(
-    net::CookieMonster* cookie_monster,
+    BrowsingDataCookieHelper* cookie_helper,
     BrowsingDataDatabaseHelper* database_helper,
     BrowsingDataLocalStorageHelper* local_storage_helper,
     BrowsingDataLocalStorageHelper* session_storage_helper,
     BrowsingDataAppCacheHelper* appcache_helper,
     BrowsingDataIndexedDBHelper* indexed_db_helper,
     BrowsingDataFileSystemHelper* file_system_helper,
     bool use_cookie_source)
     : ALLOW_THIS_IN_INITIALIZER_LIST(ui::TreeNodeModel<CookieTreeNode>(
           new CookieTreeRootNode(this))),
-      cookie_monster_(cookie_monster),
       appcache_helper_(appcache_helper),
+      cookie_helper_(cookie_helper),
       database_helper_(database_helper),
       local_storage_helper_(local_storage_helper),
       session_storage_helper_(session_storage_helper),
       indexed_db_helper_(indexed_db_helper),
       file_system_helper_(file_system_helper),
       batch_update_(0),
       use_cookie_source_(use_cookie_source) {
-  LoadCookies();
+  DCHECK(cookie_helper_);
+  cookie_helper_->StartFetching(
+      base::Bind(&CookiesTreeModel::OnCookiesModelInfoLoaded,
+                 base::Unretained(this)));
   DCHECK(database_helper_);
   database_helper_->StartFetching(NewCallback(
       this, &CookiesTreeModel::OnDatabaseModelInfoLoaded));
   DCHECK(local_storage_helper_);
   local_storage_helper_->StartFetching(NewCallback(
       this, &CookiesTreeModel::OnLocalStorageModelInfoLoaded));
   if (session_storage_helper_) {
     session_storage_helper_->StartFetching(NewCallback(
         this, &CookiesTreeModel::OnSessionStorageModelInfoLoaded));
   }
@@ skipping 10 matching lines @@
         this, &CookiesTreeModel::OnIndexedDBModelInfoLoaded));
   }
 
   if (file_system_helper_) {
     file_system_helper_->StartFetching(NewCallback(
         this, &CookiesTreeModel::OnFileSystemModelInfoLoaded));
   }
 }
 
 CookiesTreeModel::~CookiesTreeModel() {
+  cookie_helper_->CancelNotification();
   database_helper_->CancelNotification();
   local_storage_helper_->CancelNotification();
   if (session_storage_helper_)
     session_storage_helper_->CancelNotification();
   if (appcache_helper_)
     appcache_helper_->CancelNotification();
   if (indexed_db_helper_)
     indexed_db_helper_->CancelNotification();
   if (file_system_helper_)
     file_system_helper_->CancelNotification();
@@ skipping 35 matching lines @@
     case CookieTreeNode::DetailedInfo::TYPE_INDEXED_DB:
       return DATABASE;  // ditto
     case CookieTreeNode::DetailedInfo::TYPE_FILE_SYSTEM:
       return DATABASE;  // ditto
     default:
       break;
   }
   return -1;
 }
 
-void CookiesTreeModel::LoadCookies() {
-  LoadCookiesWithFilter(std::wstring());
-}
-
-void CookiesTreeModel::LoadCookiesWithFilter(const std::wstring& filter) {
-  // mmargh mmargh mmargh! delicious!
-
-  all_cookies_ = cookie_monster_->GetAllCookies();
-  CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
-  for (CookieList::iterator it = all_cookies_.begin();
-       it != all_cookies_.end(); ++it) {
-    std::string source_string = it->Source();
-    if (source_string.empty() || !use_cookie_source_) {
-      std::string domain = it->Domain();
-      if (domain.length() > 1 && domain[0] == '.')
-        domain = domain.substr(1);
-
-      // We treat secure cookies just the same as normal ones.
-      source_string = std::string(chrome::kHttpScheme) +
-          chrome::kStandardSchemeSeparator + domain + "/";
-    }
-
-    GURL source(source_string);
-    if (!filter.size() ||
-        (CookieTreeOriginNode::TitleForUrl(source).find(filter) !=
-         std::string::npos)) {
-      CookieTreeOriginNode* origin_node =
-          root->GetOrCreateOriginNode(source);
-      CookieTreeCookiesNode* cookies_node =
-          origin_node->GetOrCreateCookiesNode();
-      CookieTreeCookieNode* new_cookie = new CookieTreeCookieNode(&*it);
-      cookies_node->AddCookieNode(new_cookie);
-    }
-  }
-}
-
 void CookiesTreeModel::DeleteAllStoredObjects() {
   NotifyObserverBeginBatch();
   CookieTreeNode* root = GetRoot();
   root->DeleteStoredObjects();
   int num_children = root->child_count();
   for (int i = num_children - 1; i >= 0; --i)
     delete Remove(root, root->GetChild(i));
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
 void CookiesTreeModel::DeleteCookieNode(CookieTreeNode* cookie_node) {
   if (cookie_node == GetRoot())
     return;
   cookie_node->DeleteStoredObjects();
   CookieTreeNode* parent_node = cookie_node->parent();
   delete Remove(parent_node, cookie_node);
   if (parent_node->empty())
     DeleteCookieNode(parent_node);
 }
 
 void CookiesTreeModel::UpdateSearchResults(const std::wstring& filter) {
   CookieTreeNode* root = GetRoot();
   int num_children = root->child_count();
   NotifyObserverBeginBatch();
   for (int i = num_children - 1; i >= 0; --i)
     delete Remove(root, root->GetChild(i));
-  LoadCookiesWithFilter(filter);
+  PopulateCookieInfoWithFilter(filter);
   PopulateDatabaseInfoWithFilter(filter);
   PopulateLocalStorageInfoWithFilter(filter);
   PopulateSessionStorageInfoWithFilter(filter);
   PopulateAppCacheInfoWithFilter(filter);
   PopulateIndexedDBInfoWithFilter(filter);
   PopulateFileSystemInfoWithFilter(filter);
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
@@ skipping 40 matching lines @@
            info != origin->second.end(); ++info) {
         appcaches_node->AddAppCacheNode(
             new CookieTreeAppCacheNode(&(*info)));
       }
     }
   }
   NotifyObserverTreeNodeChanged(root);
   NotifyObserverEndBatch();
 }
 
+void CookiesTreeModel::OnCookiesModelInfoLoaded(
+    const CookieList& cookie_list) {
+  cookie_list_ = cookie_list;
+  PopulateCookieInfoWithFilter(std::wstring());
+}
+
+void CookiesTreeModel::PopulateCookieInfoWithFilter(
+    const std::wstring& filter) {
+  // mmargh mmargh mmargh! delicious!
+
+  CookieTreeRootNode* root = static_cast<CookieTreeRootNode*>(GetRoot());
+  for (CookieList::iterator it = cookie_list_.begin();
+       it != cookie_list_.end(); ++it) {
+    std::string source_string = it->Source();
+    if (source_string.empty() || !use_cookie_source_) {
+      std::string domain = it->Domain();
+      if (domain.length() > 1 && domain[0] == '.')
+        domain = domain.substr(1);
+
+      // We treat secure cookies just the same as normal ones.
+      source_string = std::string(chrome::kHttpScheme) +
+          chrome::kStandardSchemeSeparator + domain + "/";
+    }
+
+    GURL source(source_string);
+    if (!filter.size() ||
+        (CookieTreeOriginNode::TitleForUrl(source).find(filter) !=
+         std::string::npos)) {
+      CookieTreeOriginNode* origin_node =
+          root->GetOrCreateOriginNode(source);
+      CookieTreeCookiesNode* cookies_node =
+          origin_node->GetOrCreateCookiesNode();
+      CookieTreeCookieNode* new_cookie = new CookieTreeCookieNode(&*it);
+      cookies_node->AddCookieNode(new_cookie);
+    }
+  }
+}
+
 void CookiesTreeModel::OnDatabaseModelInfoLoaded(
     const DatabaseInfoList& database_info) {
   database_info_list_ = database_info;
   PopulateDatabaseInfoWithFilter(std::wstring());
 }
 
 void CookiesTreeModel::PopulateDatabaseInfoWithFilter(
     const std::wstring& filter) {
   if (database_info_list_.empty())
     return;
@@ skipping 162 matching lines @@
 
 void CookiesTreeModel::NotifyObserverEndBatch() {
   // Only notify the observers if this is the outermost call to EndBatch() if
   // called in a nested manner.
   if (--batch_update_ == 0) {
     FOR_EACH_OBSERVER(Observer,
                       cookies_observer_list_,
                       TreeModelEndBatch(this));
   }
 }