Delete cookies for site when deleting locally stored data.

chrome/browser/android/preferences/website_preference_bridge.cc

 // Copyright 2015 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/android/preferences/website_preference_bridge.h"
 
 #include "base/android/jni_android.h"
 #include "base/android/jni_string.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #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"
 #include "components/content_settings/core/browser/host_content_settings_map.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/storage_partition.h"
 #include "jni/WebsitePreferenceBridge_jni.h"
 #include "storage/browser/quota/quota_client.h"
 #include "storage/browser/quota/quota_manager.h"
 
@@ skipping 253 matching lines @@
   if (value == -1) {
     GetCookieSettings()->ResetCookieSetting(primary_pattern, secondary_pattern);
   } else {
     GetCookieSettings()->SetCookieSetting(primary_pattern, secondary_pattern,
         value ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK);
   }
 }
 
 namespace {
 
+class SiteDataDeleteHelper :
+      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();
+    for (int i = node->child_count(); i > 0; --i)
+      RecursivelyFindSiteAndDelete(node->GetChild(i - 1));
+
+    if (info.node_type == CookieTreeNode::DetailedInfo::TYPE_COOKIE &&
+        info.cookie &&
+        domain_.DomainIs(info.cookie->Domain().c_str()))

[newt (away), 2015/01/26 19:24:22]

Is this the correct way to check for cookies that should be deleted?

GURL("http://maps.google.com").DomainIs("google.com") will return true, but you
don't want to delete the cookies for maps.google.com when deleting cookies for
google.com, I believe.

Also, should we delete HTTPS cookies when the user requests to delete cookies
for an HTTP origin?

[Finnur, 2015/01/28 11:33:48]

Thanks Mike.

I convinced myself that the review I sent out was correct, but started doubting
myself upon reading Newton's reply. But now I'm coming back to thinking it was
correct after all. I'm not 100% sure, though, so I'll explain my reasoning and
we can discuss.

As Mike points out, the cookie model and they way we present sites to the user
are not consistent. We might show two sites for www.google.is (one with https
and one with http) in the sites list, but under the hood the cookies that get
created when I access https://www.google.is (note the https) look something akin
to this:

A) HOST  Domain: www.google.is 
B) DOMAIN  Domain: .google.is 
C) DOMAIN  Domain: .google.is (Accessible to javascript only)

None of those cookies have the secure_ flag set to true (a flag that means
cookies are only sent over https). 
Side question: Mike, does secure_ == true mean that the cookie is not visible on
the site when accessed over http?

Anyway, regardless of that, two things are clear to me:
1) We have no good way of deleting only http or only https cookies (as the three
cookies above show). This is what Mike touched upon, they are purely domain
bound.
2) We'll have a variety of cookies that can affect a site, some specifying exact
hosts (cookie A above), some casting a wider net (the other two), with no good
way of knowing how they were created or how many sites within the domain use it.
So (in my mind) the only thing the implementation can do is ask the question:
Does this cookie affect the site being deleted? If so, delete it. And that where
the DomainIs call comes in.

That means we're likely to delete a cookie that is shared by other sites on the
domain, so we can satisfy the requirement to delete the cookies for the site
being deleted. To be specific -- and using Newtons example that if you ask to
delete all data related to maps.google.com, you have to delete the cookie that
applies to the .google.com domain.

Right?

[newt (away), 2015/01/28 17:43:59]

Ok, I'm convinced. Thanks for walking me through the reasoning :)

+      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:
   StorageInfoFetcher(storage::QuotaManager* quota_manager,
                      const JavaRef<jobject>& java_callback)
       : env_(base::android::AttachCurrentThread()),
         quota_manager_(quota_manager),
         java_callback_(java_callback) {
   }
 
@@ skipping 195 matching lines @@
   std::string host = ConvertJavaStringToUTF8(env, jhost);
   scoped_refptr<StorageDataDeleter> storage_data_deleter(new StorageDataDeleter(
       content::BrowserContext::GetDefaultStoragePartition(
           profile)->GetQuotaManager(),
       host,
       static_cast<storage::StorageType>(type),
       ScopedJavaLocalRef<jobject>(env, java_callback)));
   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);
 }