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

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/webui/options/clear_browser_data_handler.h"
   6
   7 #include "base/basictypes.h"
   8 #include "base/bind.h"
   9 #include "base/bind_helpers.h"
  10 #include "base/command_line.h"
  11 #include "base/prefs/pref_service.h"
  12 #include "base/strings/string16.h"
  13 #include "base/values.h"
  14 #include "chrome/app/chrome_command_ids.h"
  15 #include "chrome/browser/browser_process.h"
  16 #include "chrome/browser/browsing_data/browsing_data_counter.h"
  17 #include "chrome/browser/browsing_data/browsing_data_helper.h"
  18 #include "chrome/browser/browsing_data/browsing_data_remover.h"
  19 #include "chrome/browser/browsing_data/passwords_counter.h"
  20 #include "chrome/browser/prefs/incognito_mode_prefs.h"
  21 #include "chrome/browser/profiles/profile.h"
  22 #include "chrome/browser/ui/accelerator_utils.h"
  23 #include "chrome/common/chrome_switches.h"
  24 #include "chrome/common/pref_names.h"
  25 #include "chrome/grit/generated_resources.h"
  26 #include "chrome/grit/locale_settings.h"
  27 #include "components/google/core/browser/google_util.h"
  28 #include "content/public/browser/notification_details.h"
  29 #include "content/public/browser/web_ui.h"
  30 #include "ui/base/accelerators/accelerator.h"
  31 #include "ui/base/l10n/l10n_util.h"
  32 #include "ui/events/keycodes/keyboard_codes.h"
  33
  34 namespace {
  35
  36 const char kClearBrowsingDataLearnMoreUrl[] =
  37     "https://support.google.com/chrome/?p=settings_clear_browsing_data";
  38
  39 bool AreCountersEnabled() {
  40   return base::CommandLine::ForCurrentProcess()->HasSwitch(
  41       switches::kEnableClearBrowsingDataCounters);
  42 }
  43
  44 }  // namespace
  45
  46 namespace options {
  47
  48 ClearBrowserDataHandler::ClearBrowserDataHandler()
  49     : remover_(NULL) {
  50 }
  51
  52 ClearBrowserDataHandler::~ClearBrowserDataHandler() {
  53   if (remover_)
  54     remover_->RemoveObserver(this);
  55 }
  56
  57 void ClearBrowserDataHandler::InitializeHandler() {
  58   PrefService* prefs = Profile::FromWebUI(web_ui())->GetPrefs();
  59   clear_plugin_lso_data_enabled_.Init(prefs::kClearPluginLSODataEnabled, prefs);
  60   pepper_flash_settings_enabled_.Init(prefs::kPepperFlashSettingsEnabled,
  61                                       prefs);
  62   allow_deleting_browser_history_.Init(
  63       prefs::kAllowDeletingBrowserHistory,
  64       prefs,
  65       base::Bind(&ClearBrowserDataHandler::OnBrowsingHistoryPrefChanged,
  66                  base::Unretained(this)));
  67
  68   if (AreCountersEnabled()) {
  69     AddCounter(
  70         make_scoped_ptr(new PasswordsCounter()), IDS_DEL_PASSWORDS_COUNTER);
  71     // TODO(msramek): Add counters for browsing history and cache.
  72   }
  73 }
  74
  75 void ClearBrowserDataHandler::InitializePage() {
  76   UpdateInfoBannerVisibility();
  77   OnBrowsingHistoryPrefChanged();
  78   bool removal_in_progress = !!remover_;
  79   web_ui()->CallJavascriptFunction("ClearBrowserDataOverlay.setClearing",
  80                                    base::FundamentalValue(removal_in_progress));
  81
  82   web_ui()->CallJavascriptFunction(
  83       "ClearBrowserDataOverlay.markInitializationComplete");
  84 }
  85
  86 void ClearBrowserDataHandler::UpdateInfoBannerVisibility() {
  87   base::string16 text;
  88
  89   Profile* profile = Profile::FromWebUI(web_ui());
  90   auto availability = IncognitoModePrefs::GetAvailability(profile->GetPrefs());
  91   if (availability == IncognitoModePrefs::ENABLED) {
  92     base::Time last_clear_time = base::Time::FromInternalValue(
  93         profile->GetPrefs()->GetInt64(prefs::kLastClearBrowsingDataTime));
  94
  95     const base::TimeDelta since_clear = base::Time::Now() - last_clear_time;
  96     if (since_clear < base::TimeDelta::FromHours(base::Time::kHoursPerDay)) {
  97       ui::Accelerator acc = chrome::GetPrimaryChromeAcceleratorForCommandId(
  98           IDC_NEW_INCOGNITO_WINDOW);
  99       DCHECK_NE(ui::VKEY_UNKNOWN, acc.key_code());
 100       text = l10n_util::GetStringFUTF16(IDS_CLEAR_BROWSING_DATA_INFO_BAR_TEXT,
 101                                         acc.GetShortcutText());
 102     }
 103   }
 104
 105   web_ui()->CallJavascriptFunction("ClearBrowserDataOverlay.setBannerText",
 106                                    base::StringValue(text));
 107 }
 108
 109 void ClearBrowserDataHandler::GetLocalizedValues(
 110     base::DictionaryValue* localized_strings) {
 111   DCHECK(localized_strings);
 112
 113   static OptionsStringResource resources[] = {
 114     { "clearBrowserDataLabel", IDS_CLEAR_BROWSING_DATA_LABEL },
 115     { "contentSettingsAndSearchEnginesRemain",
 116       IDS_CLEAR_BROWSING_DATA_SOME_STUFF_REMAINS },
 117     { "deleteBrowsingHistoryCheckbox", IDS_DEL_BROWSING_HISTORY_CHKBOX },
 118     { "deleteDownloadHistoryCheckbox", IDS_DEL_DOWNLOAD_HISTORY_CHKBOX },
 119     { "deleteCacheCheckbox", IDS_DEL_CACHE_CHKBOX },
 120     { "deleteCookiesCheckbox", IDS_DEL_COOKIES_CHKBOX },
 121     { "deleteCookiesFlashCheckbox", IDS_DEL_COOKIES_FLASH_CHKBOX },
 122     { "deletePasswordsCheckbox", IDS_DEL_PASSWORDS_CHKBOX },
 123     { "deleteFormDataCheckbox", IDS_DEL_FORM_DATA_CHKBOX },
 124     { "deleteHostedAppsDataCheckbox", IDS_DEL_HOSTED_APPS_DATA_CHKBOX },
 125     { "deauthorizeContentLicensesCheckbox",
 126       IDS_DEAUTHORIZE_CONTENT_LICENSES_CHKBOX },
 127     { "clearBrowserDataCommit", IDS_CLEAR_BROWSING_DATA_COMMIT },
 128     { "flashStorageUrl", IDS_FLASH_STORAGE_URL },
 129   };
 130
 131   RegisterStrings(localized_strings, resources, arraysize(resources));
 132   RegisterTitle(localized_strings, "clearBrowserDataOverlay",
 133                 IDS_CLEAR_BROWSING_DATA_TITLE);
 134   localized_strings->SetString("clearBrowsingDataLearnMoreUrl",
 135                                kClearBrowsingDataLearnMoreUrl);
 136
 137   base::ListValue* time_list = new base::ListValue;
 138   for (int i = 0; i < 5; i++) {
 139     base::string16 label_string;
 140     switch (i) {
 141       case 0:
 142         label_string = l10n_util::GetStringUTF16(IDS_CLEAR_DATA_HOUR);
 143         break;
 144       case 1:
 145         label_string = l10n_util::GetStringUTF16(IDS_CLEAR_DATA_DAY);
 146         break;
 147       case 2:
 148         label_string = l10n_util::GetStringUTF16(IDS_CLEAR_DATA_WEEK);
 149         break;
 150       case 3:
 151         label_string = l10n_util::GetStringUTF16(IDS_CLEAR_DATA_4WEEKS);
 152         break;
 153       case 4:
 154         label_string = l10n_util::GetStringUTF16(IDS_CLEAR_DATA_EVERYTHING);
 155         break;
 156     }
 157     base::ListValue* option = new base::ListValue();
 158     option->Append(new base::FundamentalValue(i));
 159     option->Append(new base::StringValue(label_string));
 160     time_list->Append(option);
 161   }
 162   localized_strings->Set("clearBrowserDataTimeList", time_list);
 163   localized_strings->SetBoolean("showDeleteBrowsingHistoryCheckboxes",
 164                                 !Profile::FromWebUI(web_ui())->IsSupervised());
 165 }
 166
 167 void ClearBrowserDataHandler::RegisterMessages() {
 168   // Setup handlers specific to this panel.
 169   web_ui()->RegisterMessageCallback("performClearBrowserData",
 170       base::Bind(&ClearBrowserDataHandler::HandleClearBrowserData,
 171                  base::Unretained(this)));
 172 }
 173
 174 void ClearBrowserDataHandler::HandleClearBrowserData(
 175     const base::ListValue* value) {
 176   // We should never be called when the previous clearing has not yet finished.
 177   CHECK(!remover_);
 178
 179   Profile* profile = Profile::FromWebUI(web_ui());
 180   PrefService* prefs = profile->GetPrefs();
 181
 182   int site_data_mask = BrowsingDataRemover::REMOVE_SITE_DATA;
 183   // Don't try to clear LSO data if it's not supported.
 184   if (!*clear_plugin_lso_data_enabled_)
 185     site_data_mask &= ~BrowsingDataRemover::REMOVE_PLUGIN_DATA;
 186
 187   int remove_mask = 0;
 188   int origin_mask = 0;
 189   if (prefs->GetBoolean(prefs::kDeleteBrowsingHistory) &&
 190       *allow_deleting_browser_history_) {
 191     remove_mask |= BrowsingDataRemover::REMOVE_HISTORY;
 192   }
 193   if (prefs->GetBoolean(prefs::kDeleteDownloadHistory) &&
 194       *allow_deleting_browser_history_) {
 195     remove_mask |= BrowsingDataRemover::REMOVE_DOWNLOADS;
 196   }
 197   if (prefs->GetBoolean(prefs::kDeleteCache))
 198     remove_mask |= BrowsingDataRemover::REMOVE_CACHE;
 199   if (prefs->GetBoolean(prefs::kDeleteCookies)) {
 200     remove_mask |= site_data_mask;
 201     origin_mask |= BrowsingDataHelper::UNPROTECTED_WEB;
 202   }
 203   if (prefs->GetBoolean(prefs::kDeletePasswords))
 204     remove_mask |= BrowsingDataRemover::REMOVE_PASSWORDS;
 205   if (prefs->GetBoolean(prefs::kDeleteFormData))
 206     remove_mask |= BrowsingDataRemover::REMOVE_FORM_DATA;
 207   // Clearing Content Licenses is only supported in Pepper Flash.
 208   if (prefs->GetBoolean(prefs::kDeauthorizeContentLicenses) &&
 209       *pepper_flash_settings_enabled_) {
 210     remove_mask |= BrowsingDataRemover::REMOVE_CONTENT_LICENSES;
 211   }
 212   if (prefs->GetBoolean(prefs::kDeleteHostedAppsData)) {
 213     remove_mask |= site_data_mask;
 214     origin_mask |= BrowsingDataHelper::PROTECTED_WEB;
 215   }
 216
 217   // BrowsingDataRemover deletes itself when done.
 218   int period_selected = prefs->GetInteger(prefs::kDeleteTimePeriod);
 219   remover_ = BrowsingDataRemover::CreateForPeriod(profile,
 220       static_cast<BrowsingDataRemover::TimePeriod>(period_selected));
 221   remover_->AddObserver(this);
 222   remover_->Remove(remove_mask, origin_mask);
 223
 224   // Store the clear browsing data time. Next time the clear browsing data
 225   // dialog is open, this time is used to decide whether to display an info
 226   // banner or not.
 227   prefs->SetInt64(prefs::kLastClearBrowsingDataTime,
 228                   base::Time::Now().ToInternalValue());
 229 }
 230
 231 void ClearBrowserDataHandler::OnBrowsingDataRemoverDone() {
 232   // No need to remove ourselves as an observer as BrowsingDataRemover deletes
 233   // itself after we return.
 234   remover_ = NULL;
 235   web_ui()->CallJavascriptFunction("ClearBrowserDataOverlay.doneClearing");
 236 }
 237
 238 void ClearBrowserDataHandler::OnBrowsingHistoryPrefChanged() {
 239   web_ui()->CallJavascriptFunction(
 240       "ClearBrowserDataOverlay.setAllowDeletingHistory",
 241       base::FundamentalValue(*allow_deleting_browser_history_));
 242 }
 243
 244 void ClearBrowserDataHandler::AddCounter(
 245     scoped_ptr<BrowsingDataCounter> counter, int text_grd_id) {
 246   DCHECK(AreCountersEnabled());
 247
 248   counter->Init(
 249       Profile::FromWebUI(web_ui()),
 250       base::Bind(&ClearBrowserDataHandler::UpdateCounterText,
 251                  base::Unretained(this),
 252                  counter->GetPrefName(),
 253                  text_grd_id));
 254   counters_.push_back(counter.Pass());
 255 }
 256
 257 void ClearBrowserDataHandler::UpdateCounterText(const std::string& pref_name,
 258                                                 int text_grd_id,
 259                                                 bool finished,
 260                                                 uint32 count) {
 261   DCHECK(AreCountersEnabled());
 262   base::string16 text = finished
 263       ? l10n_util::GetPluralStringFUTF16(text_grd_id, count)
 264       : l10n_util::GetStringUTF16(IDS_CLEAR_BROWSING_DATA_CALCULATING);
 265
 266   web_ui()->CallJavascriptFunction(
 267       "ClearBrowserDataOverlay.updateCounter",
 268       base::StringValue(pref_name),
 269       base::StringValue(text));
 270 }
 271
 272 }  // namespace options