Delete cookies for site when deleting locally stored data.

chrome/browser/android/preferences/website_preference_bridge.cc

Index: chrome/browser/android/preferences/website_preference_bridge.cc
diff --git a/chrome/browser/android/preferences/website_preference_bridge.cc b/chrome/browser/android/preferences/website_preference_bridge.cc
index 4ea9e47f788bd958f75a31abebbf9c097eb9fa10..515b43e82181dc7b69c24f220af265b478dbc159 100644
--- a/chrome/browser/android/preferences/website_preference_bridge.cc
+++ b/chrome/browser/android/preferences/website_preference_bridge.cc
@@ -12,6 +12,8 @@
 #include "base/files/file_path.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data/browsing_data_local_storage_helper.h"
+#include "chrome/browser/browsing_data/cookies_tree_model.h"
+#include "chrome/browser/browsing_data/local_data_container.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
@@ -285,6 +287,104 @@ static void SetCookieSettingForOrigin(JNIEnv* env, jclass clazz,
 
 namespace {
 
+class SiteDataDeleteHelper :

[newt (away), 2015/01/20 18:35:10]

How does desktop delete cookies and clear site data? Seems like we should be
sharing that code, rather than reinventing this rather complicated machinery.

[Finnur, 2015/01/21 14:53:05]

Yes, I had the same thought initially. "There's got to be a way to just say: Go
off (asynchronously) and delete all cookies for this one URL". Right?

There's a couple of things I found out, though.

1) Desktop is built around the idea of setting up a tree in-memory and keeping
it alive, while showing the user a list-representation of it and accept requests
to delete by node-id. In other words, Desktop has no need to look for data from
one site by url and delete it. What Desktop does is iterate multiple times over
the tree, once to send down the data and once each time the user deletes
(looking for the id of the node). We only need one pass (already know what we
want to delete).

2) The LocalDataContainer uses helper objects to gather the data and not all
helper objects are applicable across Android and Desktop. For example, Desktop
uses BrowsingDataFlashLSOHelper, which isn't needed on Android. My point is
this: Even the construction of the tree isn't going to apply cleanly across.

But, the machinery (as you call it) :) -- while being a little wordy, looks more
complex than it actually is. We're simply creating a LocalDataContainer object
along with some helper objects (that will do the actual fetch work) and simply
wait for them to come back with the dataset. Much of the complexity is just
boilerplate to keep the delete request alive while we wait for the workers to
finish and notify us. Which is code that we'd need anyway because we're
performing an async operation from a static function - right?

So... I'm not sure what makes sense to share/simplify here, but if you have
ideas I'm open to suggestions.

+      public base::RefCountedThreadSafe<SiteDataDeleteHelper>,
+      public CookiesTreeModel::Observer {
+ public:
+  SiteDataDeleteHelper(Profile* profile, const GURL& domain)
+      : profile_(profile), domain_(domain), ending_batch_processing_(false) {
+  }
+
+  void Run() {
+    AddRef();  // Balanced in TreeModelEndBatch.
+
+    content::StoragePartition* storage_partition =
+        content::BrowserContext::GetDefaultStoragePartition(profile_);
+    content::IndexedDBContext* indexed_db_context =
+        storage_partition->GetIndexedDBContext();
+    content::ServiceWorkerContext* service_worker_context =
+        storage_partition->GetServiceWorkerContext();
+    storage::FileSystemContext* file_system_context =
+        storage_partition->GetFileSystemContext();
+    LocalDataContainer* container = new LocalDataContainer(
+        new BrowsingDataCookieHelper(profile_->GetRequestContext()),
+        new BrowsingDataDatabaseHelper(profile_),
+        new BrowsingDataLocalStorageHelper(profile_),
+        NULL,
+        new BrowsingDataAppCacheHelper(profile_),
+        new BrowsingDataIndexedDBHelper(indexed_db_context),
+        BrowsingDataFileSystemHelper::Create(file_system_context),
+        BrowsingDataQuotaHelper::Create(profile_),
+        BrowsingDataChannelIDHelper::Create(profile_->GetRequestContext()),
+        new BrowsingDataServiceWorkerHelper(service_worker_context),
+        NULL);
+
+    cookies_tree_model_.reset(new CookiesTreeModel(
+        container, profile_->GetExtensionSpecialStoragePolicy(), false));
+    cookies_tree_model_->AddCookiesTreeObserver(this);
+  }
+
+  // TreeModelObserver:
+  void TreeNodesAdded(ui::TreeModel* model,
+                              ui::TreeModelNode* parent,
+                              int start,
+                              int count) override {}
+  void TreeNodesRemoved(ui::TreeModel* model,
+                                ui::TreeModelNode* parent,
+                                int start,
+                                int count) override {}
+
+  // CookiesTreeModel::Observer:
+  void TreeNodeChanged(ui::TreeModel* model, ui::TreeModelNode* node) override {
+  }
+
+  void TreeModelBeginBatch(CookiesTreeModel* model) override {
+    DCHECK(!ending_batch_processing_);  // Extra batch-start sent.
+  }
+
+  void TreeModelEndBatch(CookiesTreeModel* model) override {
+    DCHECK(!ending_batch_processing_);  // Already in end-stage.
+    ending_batch_processing_ = true;
+
+    RecursivelyFindSiteAndDelete(cookies_tree_model_->GetRoot());
+
+    // This will result in this class getting deleted.
+    Release();
+  }
+
+  void RecursivelyFindSiteAndDelete(CookieTreeNode* node) {
+    CookieTreeNode::DetailedInfo info = node->GetDetailedInfo();
+    bool delete_this_node = false;
+    if (info.node_type == CookieTreeNode::DetailedInfo::TYPE_COOKIE &&
+        info.cookie &&
+        domain_.DomainIs(info.cookie->Domain().c_str()))
+      delete_this_node = true;
+
+    for (int i = node->child_count(); i > 0; --i)
+      RecursivelyFindSiteAndDelete(node->GetChild(i - 1));
+
+    if (delete_this_node)
+      cookies_tree_model_->DeleteCookieNode(node);
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<SiteDataDeleteHelper>;
+
+  virtual ~SiteDataDeleteHelper() {}
+
+  Profile* profile_;
+
+  // The domain we want to delete data for.
+  GURL domain_;
+
+  // Keeps track of when we're ready to close batch processing.
+  bool ending_batch_processing_;
+
+  scoped_ptr<CookiesTreeModel> cookies_tree_model_;
+
+  DISALLOW_COPY_AND_ASSIGN(SiteDataDeleteHelper);
+};
+
 class StorageInfoFetcher :
       public base::RefCountedThreadSafe<StorageInfoFetcher> {
  public:
@@ -500,6 +600,14 @@ static void ClearStorageData(JNIEnv* env,
   storage_data_deleter->Run();
 }
 
+static void ClearCookieData(JNIEnv* env, jclass clazz, jstring jorigin) {
+  Profile* profile = ProfileManager::GetActiveUserProfile();
+  GURL url(ConvertJavaStringToUTF8(env, jorigin));
+  scoped_refptr<SiteDataDeleteHelper> site_data_deleter(
+      new SiteDataDeleteHelper(profile, url));
+  site_data_deleter->Run();
+}
+
 // Register native methods
 bool RegisterWebsitePreferenceBridge(JNIEnv* env) {
   return RegisterNativesImpl(env);