Add UI to the Clear Browsing Data dialog to remove Flash LSO data.

chrome/browser/ui/cocoa/clear_browsing_data_controller.mm

 // Copyright (c) 2010 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.
 
 #import "chrome/browser/ui/cocoa/clear_browsing_data_controller.h"
 
 #include "app/l10n_util.h"
 #include "base/lazy_instance.h"
 #include "base/mac_util.h"
 #include "base/scoped_nsobject.h"
+#include "chrome/browser/browser_process.h"
 #include "chrome/browser/browsing_data_remover.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/common/pref_names.h"
+#include "chrome/common/notification_details.h"
 #include "grit/locale_settings.h"
+#include "grit/generated_resources.h"
 #import "third_party/GTM/AppKit/GTMUILocalizerAndLayoutTweaker.h"
 
 NSString* const kClearBrowsingDataControllerDidDelete =
     @"kClearBrowsingDataControllerDidDelete";
 NSString* const kClearBrowsingDataControllerRemoveMask =
     @"kClearBrowsingDataControllerRemoveMask";
 
 @interface ClearBrowsingDataController(Private)
 - (void)initFromPrefs;
 - (void)persistToPrefs;
 - (void)dataRemoverDidFinish;
 @end
 
 class ClearBrowsingObserver : public BrowsingDataRemover::Observer {
  public:
   ClearBrowsingObserver(ClearBrowsingDataController* controller)
       : controller_(controller) { }
   void OnBrowsingDataRemoverDone() { [controller_ dataRemoverDidFinish]; }
  private:
   ClearBrowsingDataController* controller_;
 };
 
+namespace clear_browsing_data_controller_internal {
+
+// A C++ class registered for changes in preferences.
+class PrefObserverBridge : public NotificationObserver {
+ public:
+  PrefObserverBridge(id controller)
+      : controller_(controller) {}
+
+  virtual ~PrefObserverBridge() {}
+
+  virtual void Observe(NotificationType type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) {
+    if (type == NotificationType::PREF_CHANGED) {
+      const std::string& pref = *(Details<std::string>(details).ptr());
+      if (pref == prefs::kClearPluginLSODataEnabled) {
+        [controller_ willChangeValueForKey:@"clearLSODataEnabled"];
+        [controller_ didChangeValueForKey:@"clearLSODataEnabled"];
+        [controller_ willChangeValueForKey:@"clearLSODataChecked"];
+        [controller_ didChangeValueForKey:@"clearLSODataChecked"];
+        [controller_ willChangeValueForKey:@"clearLSODataMessage"];
+        [controller_ didChangeValueForKey:@"clearLSODataMessage"];
+      }
+    } else {
+      NOTREACHED();
+    }
+  }
+
+ private:
+  id controller_;  // weak, owns us
+};
+
+}  // namespace clear_browsing_data_controller_internal
+
 namespace {
 
 typedef std::map<Profile*, ClearBrowsingDataController*> ProfileControllerMap;
 
 static base::LazyInstance<ProfileControllerMap> g_profile_controller_map(
     base::LINKER_INITIALIZED);
 
 } // namespace
 
 @implementation ClearBrowsingDataController
 
 @synthesize clearBrowsingHistory = clearBrowsingHistory_;
 @synthesize clearDownloadHistory = clearDownloadHistory_;
 @synthesize emptyCache = emptyCache_;
 @synthesize deleteCookies = deleteCookies_;
 @synthesize clearSavedPasswords = clearSavedPasswords_;
+@synthesize clearLSOData = clearLSOData_;
 @synthesize clearFormData = clearFormData_;
 @synthesize timePeriod = timePeriod_;
 @synthesize isClearing = isClearing_;
 
+- (BOOL)clearLSODataChecked {
+  return clearLSOData_ && clearLSODataEnabled_.GetValue();
+}
+
+- (void)setClearLSODataChecked:(BOOL)value {
+  DCHECK(clearLSODataEnabled_.GetValue());
+  clearLSOData_ = value;
+}
+
+- (BOOL)clearLSODataEnabled {
+  return clearLSODataEnabled_.GetValue();
+}
+
+- (NSString*)clearLSODataMessage {
+  if (self.clearLSODataEnabled)
+    return nil;
+  return l10n_util::GetNSString(IDS_LSO_CLEAR_MESSAGE);
+}
+
 + (void)showClearBrowsingDialogForProfile:(Profile*)profile {
   ClearBrowsingDataController* controller =
       [ClearBrowsingDataController controllerForProfile:profile];
   if (![controller isWindowLoaded]) {
     // This function needs to return instead of blocking, to match the windows
     // api call.  It caused problems when launching the dialog from the
     // DomUI history page.  See bug and code review for more details.
     // http://crbug.com/37976
     [controller performSelector:@selector(runModalDialog)
                      withObject:nil
@@ skipping 27 matching lines @@
 - (id)initWithProfile:(Profile*)profile {
   DCHECK(profile);
   // Use initWithWindowNibPath:: instead of initWithWindowNibName: so we
   // can override it in a unit test.
   NSString *nibpath = [mac_util::MainAppBundle()
                         pathForResource:@"ClearBrowsingData"
                                  ofType:@"nib"];
   if ((self = [super initWithWindowNibPath:nibpath owner:self])) {
     profile_ = profile;
     observer_.reset(new ClearBrowsingObserver(self));
+    PrefService* prefs = g_browser_process->local_state();
+    // In unit tests |local_state()| can be NULL.
+    if (!prefs)
+      prefs = profile->GetPrefs();
+    prefObserver_.reset(
+        new clear_browsing_data_controller_internal::PrefObserverBridge(self));
+    clearLSODataEnabled_.Init(prefs::kClearPluginLSODataEnabled,
+                              prefs,
+                              prefObserver_.get());
     [self initFromPrefs];
   }
   return self;
 }
 
 - (void)dealloc {
   if (remover_) {
     // We were destroyed while clearing history was in progress. This can only
     // occur during automated tests (normally the user can't close the dialog
     // while clearing is in progress as the dialog is modal and not closeable).
@@ skipping 42 matching lines @@
   if (clearBrowsingHistory_)
     removeMask |= BrowsingDataRemover::REMOVE_HISTORY;
   if (clearDownloadHistory_)
     removeMask |= BrowsingDataRemover::REMOVE_DOWNLOADS;
   if (emptyCache_)
     removeMask |= BrowsingDataRemover::REMOVE_CACHE;
   if (deleteCookies_)
      removeMask |= BrowsingDataRemover::REMOVE_COOKIES;
   if (clearSavedPasswords_)
      removeMask |= BrowsingDataRemover::REMOVE_PASSWORDS;
+  if (self.clearLSOData)
+    removeMask |= BrowsingDataRemover::REMOVE_LSO_DATA;
   if (clearFormData_)
     removeMask |= BrowsingDataRemover::REMOVE_FORM_DATA;
   return removeMask;
 }
 
 // Called when the user clicks the "clear" button. Do the work and persist
 // the prefs for next time. We don't stop the modal session until we get
 // the callback from the BrowsingDataRemover so the window stays on the screen.
 // While we're working, dim the buttons so the user can't click them.
 - (IBAction)clearData:(id)sender {
@@ skipping 42 matching lines @@
 // Initialize the bools from prefs using the setters to be KVO-compliant.
 - (void)initFromPrefs {
   PrefService* prefs = profile_->GetPrefs();
   [self setClearBrowsingHistory:
       prefs->GetBoolean(prefs::kDeleteBrowsingHistory)];
   [self setClearDownloadHistory:
       prefs->GetBoolean(prefs::kDeleteDownloadHistory)];
   [self setEmptyCache:prefs->GetBoolean(prefs::kDeleteCache)];
   [self setDeleteCookies:prefs->GetBoolean(prefs::kDeleteCookies)];
   [self setClearSavedPasswords:prefs->GetBoolean(prefs::kDeletePasswords)];
+  [self setClearLSOData:prefs->GetBoolean(prefs::kDeleteLSOData)];
   [self setClearFormData:prefs->GetBoolean(prefs::kDeleteFormData)];
   [self setTimePeriod:prefs->GetInteger(prefs::kDeleteTimePeriod)];
 }
 
 // Save the checkbox values to the preferences.
 - (void)persistToPrefs {
   PrefService* prefs = profile_->GetPrefs();
   prefs->SetBoolean(prefs::kDeleteBrowsingHistory,
                     [self clearBrowsingHistory]);
   prefs->SetBoolean(prefs::kDeleteDownloadHistory,
                     [self clearDownloadHistory]);
   prefs->SetBoolean(prefs::kDeleteCache, [self emptyCache]);
   prefs->SetBoolean(prefs::kDeleteCookies, [self deleteCookies]);
   prefs->SetBoolean(prefs::kDeletePasswords, [self clearSavedPasswords]);
+  prefs->SetBoolean(prefs::kDeleteLSOData, [self clearLSOData]);
   prefs->SetBoolean(prefs::kDeleteFormData, [self clearFormData]);
   prefs->SetInteger(prefs::kDeleteTimePeriod, [self timePeriod]);
 }
 
 // Called when the data remover object is done with its work. Close the window.
 // The remover will delete itself. End the modal session at this point.
 - (void)dataRemoverDidFinish {
   NSNotificationCenter* center = [NSNotificationCenter defaultCenter];
   int removeMask = [self removeMask];
   NSDictionary* userInfo =
       [NSDictionary dictionaryWithObject:[NSNumber numberWithInt:removeMask]
                                 forKey:kClearBrowsingDataControllerRemoveMask];
   [center postNotificationName:kClearBrowsingDataControllerDidDelete
                         object:self
                       userInfo:userInfo];
 
   [self closeDialog];
   [[self window] orderOut:self];
   [self setIsClearing:NO];
   remover_ = NULL;
 }
 
 @end