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

chrome/browser/views/blocked_popup_container.h

 // 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.
 
 // Defines the public interface for the blocked popup notifications. This
 // interface should only be used by TabContents. Users and subclasses of
 // TabContents should use the appropriate methods on TabContents to access
 // information about blocked popups.
 
 #ifndef CHROME_BROWSER_VIEWS_BLOCKED_POPUP_CONTAINER_H_
 #define CHROME_BROWSER_VIEWS_BLOCKED_POPUP_CONTAINER_H_
 
+#include <set>
 #include <utility>
 #include <vector>
 
 #include "app/animation.h"
 #include "base/gfx/rect.h"
 #include "chrome/browser/tab_contents/constrained_window.h"
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
 #include "chrome/common/notification_registrar.h"
 #include "views/controls/button/button.h"
 #include "views/controls/button/menu_button.h"
 #include "views/controls/menu/menu.h"
 #include "views/view.h"
 #include "views/widget/widget_win.h"
 
 class BlockedPopupContainer;
+class PrefService;
 class Profile;
 class TabContents;
 class TextButton;
 
 namespace views {
 class ImageButton;
 }
 
 // The view presented to the user notifying them of the number of popups
 // blocked. This view should only be used inside of BlockedPopupContainer.
@@ skipping 46 matching lines @@
 
 // Takes ownership of TabContents that are unrequested popup windows and
 // presents an interface to the user for launching them. (Or never showing them
 // again).
 class BlockedPopupContainer : public Animation,
                               public ConstrainedWindow,
                               public NotificationObserver,
                               public TabContentsDelegate,
                               public views::WidgetWin {
  public:
-  virtual ~BlockedPopupContainer();
+  static void RegisterUserPrefs(PrefService* prefs);
 
   // Creates a BlockedPopupContainer, anchoring the container to the lower
   // right corner.
   static BlockedPopupContainer* Create(
       TabContents* owner, Profile* profile, const gfx::Point& initial_anchor);
 
+  virtual ~BlockedPopupContainer();
+
   // Adds a popup to this container. |bounds| are the window bounds requested by
   // the popup window.
   void AddTabContents(TabContents* tab_contents,
                       const gfx::Rect& bounds,
                       const std::string& host);
 
   // Shows the blocked popup at index |index|.
   void LaunchPopupAtIndex(size_t index);
 
   // Returns the number of blocked popups
@@ skipping 106 matching lines @@
     std::string host;
   };
   typedef std::vector<BlockedPopup> BlockedPopups;
 
   // TabContents is the popup contents.  string is opener hostname.
   typedef std::map<TabContents*, std::string> UnblockedPopups;
 
   // string is hostname.  bool is whitelisted status.
   typedef std::map<std::string, bool> PopupHosts;
 
+  // string is hostname.
+  typedef std::set<std::string> Whitelist;
+
   // Creates a container for a certain TabContents.
-  BlockedPopupContainer(TabContents* owner, Profile* profile);
+  BlockedPopupContainer(TabContents* owner, PrefService* prefs);
 
   // Overridden from Animation:
   // Changes the visibility percentage of the BlockedPopupContainer. This is
   // called while animating in or out.
   virtual void AnimateToState(double state);
 
   // Overridden from notificationObserver:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
@@ skipping 33 matching lines @@
   void EraseDataForPopupAndUpdateUI(BlockedPopups::iterator i);
 
   // Same as above, but works on the unblocked popup list, and returns the
   // iterator that results from calling erase().
   UnblockedPopups::iterator EraseDataForPopupAndUpdateUI(
       UnblockedPopups::iterator i);
 
   // The TabContents that owns and constrains this BlockedPopupContainer.
   TabContents* owner_;
 
+  // The PrefService we can query to find out what's on the whitelist.
+  PrefService* prefs_;
+
   // Registrar to handle notifications we care about.
   NotificationRegistrar registrar_;
 
+  // The whitelisted hosts, which we allow to open popups directly.
+  Whitelist whitelist_;
+
   // Information about all blocked popups.
   BlockedPopups blocked_popups_;
 
   // Information about all unblocked popups.
   UnblockedPopups unblocked_popups_;
 
   // Information about all popup hosts.
   PopupHosts popup_hosts_;
 
   // Our associated view object.
@@ skipping 12 matching lines @@
   // bounds while animating in or out).
   gfx::Rect bounds_;
 
   // The bottom right corner of where we should appear in our parent window.
   gfx::Point anchor_point_;
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(BlockedPopupContainer);
 };
 
 #endif