Add a button to clear local storage for a given origin to Website Settings dialog.

chrome/browser/ui/webui/options/website_settings_handler.cc

 // Copyright 2014 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/ui/webui/options/website_settings_handler.h"
 
+#include "apps/app_window_registry.h"
 #include "chrome/browser/content_settings/content_settings_utils.h"
 #include "chrome/browser/content_settings/host_content_settings_map.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/tab_contents/tab_contents_iterator.h"
+#include "content/public/browser/dom_storage_context.h"
+#include "content/public/browser/storage_partition.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/common/constants.h"
+#include "extensions/common/extension.h"
 #include "grit/generated_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/l10n/time_format.h"
 #include "ui/base/text/bytes_formatting.h"
 
 namespace {
 
 const int kHttpPort = 80;
 const int kHttpsPort = 443;
 const char kPreferencesSource[] = "preference";
@@ skipping 25 matching lines @@
       {"websitesLabelGeolocation", IDS_WEBSITE_SETTINGS_TYPE_LOCATION},
       {"websitesLabelMediaStream", IDS_WEBSITE_SETTINGS_TYPE_MEDIASTREAM},
       {"websitesLabelNotifications", IDS_WEBSITE_SETTINGS_TYPE_NOTIFICATIONS},
       {"websitesLabelStorage", IDS_WEBSITE_SETTINGS_TYPE_STORAGE},
       {"websitesLocationDescription",
        IDS_WEBSITE_SETTINGS_LOCATION_DESCRIPTION},
       {"websitesMediastreamDescription",
        IDS_WEBSITE_SETTINGS_MEDIASTREAM_DESCRIPTION},
       {"websitesNotificationsDescription",
        IDS_WEBSITE_SETTINGS_NOTIFICATIONS_DESCRIPTION},
+      {"websitesButtonClear", IDS_WEBSITE_SETTINGS_STORAGE_CLEAR_BUTTON},
   };
 
   RegisterStrings(localized_strings, resources, arraysize(resources));
   RegisterTitle(
       localized_strings, "websiteSettingsPage", IDS_WEBSITE_SETTINGS_TITLE);
 }
 
 void WebsiteSettingsHandler::InitializeHandler() {
   Profile* profile = Profile::FromWebUI(web_ui());
   HostContentSettingsMap* settings = profile->GetHostContentSettingsMap();
@@ skipping 23 matching lines @@
 
   web_ui()->RegisterMessageCallback(
       "setOriginPermission",
       base::Bind(&WebsiteSettingsHandler::HandleSetOriginPermission,
                  base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       "maybeShowEditPage",
       base::Bind(&WebsiteSettingsHandler::HandleMaybeShowEditPage,
                  base::Unretained(this)));
+
+  web_ui()->RegisterMessageCallback(
+      "deleteLocalStorage",
+      base::Bind(&WebsiteSettingsHandler::HandleDeleteLocalStorage,
+                 base::Unretained(this)));
+
+  web_ui()->RegisterMessageCallback(
+      "stopOrigin",
+      base::Bind(&WebsiteSettingsHandler::HandleStopOrigin,
+                 base::Unretained(this)));
 }
 
 // content_settings::Observer implementation.
 void WebsiteSettingsHandler::OnContentSettingChanged(
     const ContentSettingsPattern& primary_pattern,
     const ContentSettingsPattern& secondary_pattern,
     ContentSettingsType content_type,
     std::string resource_identifier) {
   Update();
 }
@@ skipping 48 matching lines @@
 
   last_site_ = last_site;
   base::StringValue site_value(site);
   web_ui()->CallJavascriptFunction("WebsiteSettingsManager.showEditPage",
                                    site_value);
 }
 
 void WebsiteSettingsHandler::OnLocalStorageFetched(const std::list<
     BrowsingDataLocalStorageHelper::LocalStorageInfo>& storage) {
   local_storage_list_ = storage;
-  UpdateLocalStorage();
+  Update();
+  GetInfoForOrigin(last_site_, false);
 }
 
 void WebsiteSettingsHandler::Update() {
   DCHECK(!last_setting_.empty());
   if (last_setting_ == kStorage)
     UpdateLocalStorage();
   else
     UpdateOrigins();
 }
 
@@ skipping 71 matching lines @@
 
 void WebsiteSettingsHandler::HandleGetOriginInfo(const base::ListValue* args) {
   std::string url;
   bool rv = args->GetString(0, &url);
   DCHECK(rv);
   GURL origin(url);
 
   if (!origin.is_valid())
     return;
 
-  GetInfoForOrigin(origin);
+  GetInfoForOrigin(origin, true);
 }
 
 void WebsiteSettingsHandler::HandleSetOriginPermission(
     const base::ListValue* args) {
   std::string setting_name;
   bool rv = args->GetString(0, &setting_name);
   DCHECK(rv);
   ContentSettingsType settings_type;
   rv = content_settings::GetTypeFromName(setting_name, &settings_type);
   DCHECK(rv);
@@ skipping 47 matching lines @@
   scoped_ptr<base::Value> v(map->GetWebsiteSetting(
       last_site_, last_site_, settings_type, std::string(), &info));
   map->SetNarrowestWebsiteSetting(primary_pattern,
                                   secondary_pattern,
                                   settings_type,
                                   std::string(),
                                   setting,
                                   info);
 }
 
-void WebsiteSettingsHandler::GetInfoForOrigin(const GURL& site_url) {
+void WebsiteSettingsHandler::HandleDeleteLocalStorage(
+    const base::ListValue* args) {
+  DCHECK(!last_site_.is_empty());
+  DeleteLocalStorage(last_site_);
+}
+
+void WebsiteSettingsHandler::HandleStopOrigin(const base::ListValue* args) {
+  DCHECK(!last_site_.is_empty());
+  StopOrigin(last_site_);
+}
+
+void WebsiteSettingsHandler::GetInfoForOrigin(const GURL& site_url,
+                                              bool show_page) {
   Profile* profile = Profile::FromWebUI(web_ui());
   HostContentSettingsMap* map = profile->GetHostContentSettingsMap();
 
   double storage = 0.0;
   for (LocalStorageList::const_iterator it = local_storage_list_.begin();
        it != local_storage_list_.end();
        it++) {
     if (it->origin_url == site_url) {
       storage = static_cast<double>(it->size);
       break;
@@ skipping 51 matching lines @@
     permission_info->SetWithoutPathExpansion("options", options);
     permission_info->SetBooleanWithoutPathExpansion(
         "editable", info.source == content_settings::SETTING_SOURCE_USER);
     permissions->SetWithoutPathExpansion(
         content_settings::GetTypeName(permission_type), permission_info);
   }
 
   base::Value* storage_used = new base::StringValue(l10n_util::GetStringFUTF16(
       IDS_WEBSITE_SETTINGS_STORAGE_USED, ui::FormatBytes(storage)));
 
-  web_ui()->CallJavascriptFunction(
-      "WebsiteSettingsEditor.populateOrigin", *storage_used, *permissions);
+  web_ui()->CallJavascriptFunction("WebsiteSettingsEditor.populateOrigin",
+                                   *storage_used,
+                                   *permissions,
+                                   base::FundamentalValue(show_page));
 }
 
 void WebsiteSettingsHandler::UpdateLocalStorage() {
   base::DictionaryValue local_storage_map;
   for (LocalStorageList::const_iterator it = local_storage_list_.begin();
        it != local_storage_list_.end();
        it++) {
     std::string origin = it->origin_url.spec();
 
     if (origin.find(last_filter_) == base::string16::npos)
       continue;
 
     base::DictionaryValue* origin_entry = new base::DictionaryValue();
     origin_entry->SetWithoutPathExpansion(
         "usage", new base::FundamentalValue(static_cast<double>(it->size)));
     origin_entry->SetWithoutPathExpansion(
         "usageString", new base::StringValue(ui::FormatBytes(it->size)));
     local_storage_map.SetWithoutPathExpansion(origin, origin_entry);
   }
   web_ui()->CallJavascriptFunction("WebsiteSettingsManager.populateOrigins",
                                    local_storage_map);
 }
 
+void WebsiteSettingsHandler::StopOrigin(const GURL& site_url) {
+  Profile* profile = Profile::FromWebUI(web_ui());
+  if (site_url.SchemeIs(extensions::kExtensionScheme)) {
+    const extensions::Extension* extension =
+        extensions::ExtensionRegistry::Get(profile)
+            ->enabled_extensions()
+            .GetHostedAppByURL(site_url);
+    if (extension) {
+      apps::AppWindowRegistry::Get(profile)
+          ->CloseAllAppWindowsForApp(extension->id());
+    }
+  }
+
+  for (TabContentsIterator it; !it.done(); it.Next()) {
+    if (it->GetLastCommittedURL().GetOrigin() == site_url &&
+        profile == Profile::FromBrowserContext(it->GetBrowserContext())) {

[Bernhard Bauer, 2014/08/22 20:42:39]

How does this interact with incognito?

[Daniel Nishi, 2014/08/22 21:45:25]

Incognito isn't affected. I'm pretty sure it is because there isn't ptr
equality, since the on-the-record Profile owns the off-the-record one.

Also, you can't get the chrome://settings page in incognito to my knowledge, so
you can't use it to stop incognito pages.

[Bernhard Bauer, 2014/08/22 21:54:36]

Yeah, I was more wondering whether that's something we would want to do... We do
show incognito content settings in chrome://settings, for example. 

[Daniel Nishi, 2014/08/22 22:12:47]

I did a little experiment -- you can see OTR content settings for everything
except location, notifications, and mediastream, making this incognito behavior
actually match the exceptions area.

It sounds like that might be a bug, though. Is the proper behavior to display
the OTR content settings both here and in the content settings exceptions pages?

[Bernhard Bauer, 2014/08/22 22:41:27]

Yeah, I think so. We could probably mark them up differently so it's clear
they're only temporary.

+      it->Close();

[Bernhard Bauer, 2014/08/22 20:42:39]

This closes the tabs completely, right? Is that the desired behavior? Could we
discard the tab instead (see TabStripModel::DiscardWebContentsAt)?

[Daniel Nishi, 2014/08/22 21:45:25]

Ooh. I didn't know about the Discard functionality.

Now using it.

+    }
+  }
+}
+
+void WebsiteSettingsHandler::DeleteLocalStorage(const GURL& site_url) {
+  Profile* profile = Profile::FromWebUI(web_ui());
+  content::DOMStorageContext* dom_storage_context_ =
+      content::BrowserContext::GetDefaultStoragePartition(profile)
+          ->GetDOMStorageContext();
+  dom_storage_context_->DeleteLocalStorage(site_url);
+
+  // Load a new BrowsingDataLocalStorageHelper to update.
+  local_storage_ = NULL;

[Bernhard Bauer, 2014/08/22 20:42:39]

Is this assignment really necessary?

[Daniel Nishi, 2014/08/22 21:45:25]

Hmm. I think I misunderstood a comment in the scoped_refptr documentation.

I've taken it out.

+  local_storage_ = new BrowsingDataLocalStorageHelper(profile);
+
+  local_storage_->StartFetching(
+      base::Bind(&WebsiteSettingsHandler::OnLocalStorageFetched,
+                 weak_ptr_factory_.GetWeakPtr()));
+}
+
 }  // namespace options