Implement the popup blocking whitelist pref. This makes the whitelist actual...

chrome/browser/views/blocked_popup_container.cc

 // Copyright (c) 2008 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.
 
 // Implementation of BlockedPopupContainer and its corresponding View
 // class. The BlockedPopupContainer is the sort of Model class which owns the
 // blocked popups' TabContents (but like most Chromium interface code, it there
 // isn't a strict Model/View separation), and BlockedPopupContainerView
 // presents the user interface controls, creates and manages the popup menu.
 
 #include "chrome/browser/views/blocked_popup_container.h"
 
 #include <math.h>
 
 #include "app/gfx/chrome_canvas.h"
 #include "app/gfx/path.h"
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/string_util.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/common/notification_service.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/common/pref_service.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "views/background.h"
 #include "views/controls/button/image_button.h"
 
 namespace {
 // A number larger than the internal popup count on the Renderer; meant for
 // preventing a compromised renderer from exhausting GDI memory by spawning
 // infinite windows.
 const int kImpossibleNumberOfPopups = 30;
@@ skipping 180 matching lines @@
 bool BlockedPopupContainerView::IsItemChecked(int id) const {
   if (id > kImpossibleNumberOfPopups) {
     return container_->IsHostWhitelisted(static_cast<size_t>(
         id - kImpossibleNumberOfPopups - 1));
   }
 
   return false;
 }
 
 void BlockedPopupContainerView::ExecuteCommand(int id) {
-  DCHECK(id > 0);
+  DCHECK_GT(id, 0);
   size_t id_size_t = static_cast<size_t>(id);
   if (id_size_t > kImpossibleNumberOfPopups) {
     // Decrement id since all index based commands have 1 added to them. (See
     // ButtonPressed() for detail).
     container_->ToggleWhitelistingForHost(
         id_size_t - kImpossibleNumberOfPopups - 1);
   } else {
     container_->LaunchPopupAtIndex(id_size_t - 1);
   }
 }
 
 // static
+void BlockedPopupContainer::RegisterUserPrefs(PrefService* prefs) {
+  prefs->RegisterListPref(prefs::kPopupWhitelistedHosts);
+}
+
+// static
 BlockedPopupContainer* BlockedPopupContainer::Create(
     TabContents* owner, Profile* profile, const gfx::Point& initial_anchor) {
-  BlockedPopupContainer* container = new BlockedPopupContainer(owner, profile);
+  BlockedPopupContainer* container =
+      new BlockedPopupContainer(owner, profile->GetPrefs());
   container->Init(initial_anchor);
   return container;
 }
 
 BlockedPopupContainer::~BlockedPopupContainer() {
 }
 
 BlockedPopupContainer::BlockedPopupContainer(TabContents* owner,
-                                             Profile* profile)
+                                             PrefService* prefs)
     : Animation(kFramerate, NULL),
       owner_(owner),
+      prefs_(prefs),
       container_view_(NULL),
       has_been_dismissed_(false),
       in_show_animation_(false),
       visibility_percentage_(0) {
+  // Copy whitelist pref into local member that's easier to use.
+  const ListValue* whitelist_pref =
+      prefs_->GetList(prefs::kPopupWhitelistedHosts);
+  // Careful: The returned value could be NULL if the pref has never been set.
+  if (whitelist_pref != NULL) {
+    for (ListValue::const_iterator i(whitelist_pref->begin());
+         i != whitelist_pref->end(); ++i) {
+      std::string host;
+      (*i)->GetAsString(&host);
+      whitelist_.insert(host);
+    }
+  }
 }
 
 void BlockedPopupContainer::AddTabContents(TabContents* tab_contents,
                                            const gfx::Rect& bounds,
                                            const std::string& host) {
-  bool whitelisted = false;  // TODO: Check if host is on whitelist.
-
   // Show whitelisted popups immediately.
+  bool whitelisted = !!whitelist_.count(host);
   if (whitelisted)
     owner_->AddNewContents(tab_contents, NEW_POPUP, bounds, true, GURL());
 
   if (has_been_dismissed_) {
     // Don't want to show any other UI.
     if (!whitelisted)
       delete tab_contents;  // Discard blocked popups entirely.
     return;
   }
 
@@ skipping 13 matching lines @@
     }
     blocked_popups_.push_back(BlockedPopup(tab_contents, bounds, host));
 
     tab_contents->set_delegate(this);
   }
 
   PopupHosts::const_iterator i(popup_hosts_.find(host));
   if (i == popup_hosts_.end())
     popup_hosts_[host] = whitelisted;
   else
-    DCHECK(!i->second);  // This host was already reported as whitelisted!
+    DCHECK_EQ(whitelisted, i->second);
 
   // Update UI.
   container_view_->UpdateLabel();
   SetWindowPos(HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_SHOWWINDOW);
   if (!Animation::IsAnimating() && visibility_percentage_ < 1.0) {
     in_show_animation_ = true;
     Animation::SetDuration(kShowAnimationDurationMS);
     Animation::Start();
   }
   owner_->PopupNotificationVisibilityChanged(true);
@@ skipping 50 matching lines @@
 bool BlockedPopupContainer::IsHostWhitelisted(size_t index) const {
   PopupHosts::const_iterator i(ConvertHostIndexToIterator(index));
   return (i == popup_hosts_.end()) ? false : i->second;
 }
 
 void BlockedPopupContainer::ToggleWhitelistingForHost(size_t index) {
   PopupHosts::const_iterator i(ConvertHostIndexToIterator(index));
   const std::string& host = i->first;
   bool should_whitelist = !i->second;
   popup_hosts_[host] = should_whitelist;
-  // TODO: Update whitelist pref.
 
+  ListValue* whitelist_pref =
+      prefs_->GetMutableList(prefs::kPopupWhitelistedHosts);
   if (should_whitelist) {
+    whitelist_.insert(host);
+    whitelist_pref->Append(new StringValue(host));
+
     // Open the popups in order.
     for (size_t j = 0; j < blocked_popups_.size(); ) {
       if (blocked_popups_[j].host == host)
         LaunchPopupAtIndex(j);  // This shifts the rest of the entries down.
       else
         ++j;
     }
   } else {
+    // Remove from whitelist.
+    whitelist_.erase(host);
+    StringValue host_value(host);
+    whitelist_pref->Remove(&host_value);
+
     for (UnblockedPopups::iterator i(unblocked_popups_.begin());
          i != unblocked_popups_.end(); ) {
       TabContents* tab_contents = i->first;
       TabContentsDelegate* delegate = tab_contents->delegate();
       if ((i->second == host) && delegate->IsPopup(tab_contents)) {
         // Convert the popup back into a blocked popup.
         delegate->DetachContents(tab_contents);
         tab_contents->set_delegate(this);
 
         // Add the popup to the blocked list.  (Do this before the below call!)
@@ skipping 256 matching lines @@
   }
 
   // Erase the popup and update the UI.
   UnblockedPopups::iterator next_popup = unblocked_popups_.erase(i);
   if (blocked_popups_.empty() && unblocked_popups_.empty())
     HideSelf();
   else
     container_view_->UpdateLabel();
   return next_popup;
 }