Introduced the URLBlacklistManager, and wired it to various places.

chrome/browser/policy/host_blacklist_manager.h

+// Copyright (c) 2011 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.
+
+#ifndef CHROME_BROWSER_POLICY_HOST_BLACKLIST_MANAGER_H_
+#define CHROME_BROWSER_POLICY_HOST_BLACKLIST_MANAGER_H_
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/compiler_specific.h"
+#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_ptr.h"
+#include "chrome/browser/prefs/pref_change_registrar.h"
+#include "content/common/notification_observer.h"
+
+class CancelableTask;
+class GURL;
+class NotificationDetails;
+class NotificationSource;
+class PrefService;
+class Profile;
+
+namespace base {
+class ListValue;
+}
+
+namespace policy {
+
+// Tracks the blacklist policies for a given profile, and updates it on changes.

[willchan no longer on Chromium, 2011/08/26 11:40:21]

The ownership of this object should be explained in this header file. I think
it's weird that it's refcounted. I suggest you make it owned by the
ProfileIOData. Instantiate it on the UI thread and then pass ownership to the
ProfileIOData. The only weird thing about this then would be the FILE thread
details. You construct the updated blacklist on the FILE thread, and then post
the update to the IO thread, but it may have disappeared by that point. The
solution is to either use PostTaskAndReply() or roll your own tasks. I suggest
you use PostTaskAndReply(). Use weak pointers, so when you bounce back to the IO
thread, then if HostBlacklistManager is already deleted, then the update is
ignored.

[Joao da Silva, 2011/08/29 11:24:25]

Done. It took a while to figure how to do this, and I think the current
iteration makes sense. The instance is created and destroyed from profile IO
data, first through the UI thread and then through the IO thread. It's using
WeakPtrFactories to handle the FILE thread issue; a weak ptr (valid on the IO
thread) is passed around while rebuilding the blacklist, and is verified before
calling SetBlacklist. I'm using custom tasks to handle ownership of the vectors
and the Blacklist.

+class HostBlacklistManager
+    : public base::RefCountedThreadSafe<HostBlacklistManager>,
+      public NotificationObserver {
+ public:
+  explicit HostBlacklistManager(Profile* profile);
+
+  // Call once to initialize the service on the UI thread.
+  // This is a separate method because it involves adding a ref to |this|
+  // (through NewRunnableMethod), which isn't allowed in the ctor.
+  void Initialize();
+
+  // Called on shutdown or destruction of the profile. The
+  // ChromeNetworkDelegate can still hold a reference to |this| on the IO thread
+  // but the PrefChangeRegistrar must clean up on the UI thread.
+  // After calling ShutdownOnUIThread(), the blacklist will still be enforced
+  // but it won't react to updates of the policies.
+  void ShutdownOnUIThread();
+
+  // Returns true if |url| is blocked by the current blacklist. This must only
+  // be invoked from the IO thread.
+  bool ShouldBlockRequest(const GURL& url) const;
+
+  // Registers the preferences related to blacklisting in the given PrefService.
+  static void RegisterPrefs(PrefService* pref_service);
+
+ private:
+  friend class base::RefCountedThreadSafe<HostBlacklistManager>;
+  friend class BuildBlacklistTask;

[willchan no longer on Chromium, 2011/08/26 11:40:21]

Why are these friends? Why don't you just make the member functions public? The
ChromeNetworkDelegate should only have const access to the blacklist. And the
Profile should be updating it via non-const member functions.

[Joao da Silva, 2011/08/29 11:24:25]

Done.

+  friend class SetBlacklistTask;
+  friend class TestingHostBlacklistManager;
+
+  class Blacklist;
+
+  virtual ~HostBlacklistManager();
+
+  virtual void Observe(int type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) OVERRIDE;
+
+  void ScheduleUpdate();
+  virtual void PostUpdateTask();  // Virtual for testing.
+  virtual void Update();  // Virtual for testing.
+
+  void BuildBlacklist(const std::vector<std::string>* blacklist,
+                      const std::vector<std::string>* whitelist);
+  void SetBlacklist(Blacklist* blacklist);
+
+  // Non NULL when a pending update task exists. This is only modified on
+  // the UI thread, and is used to avoid duplicate updates when both policies
+  // change at the same time.
+  CancelableTask* update_task_;
+
+  // Used to track the policies and update the blacklist on changes.
+  PrefChangeRegistrar pref_change_registrar_;
+  PrefService* pref_service_;  // Weak.
+
+  // The current blacklist. Lives in the IO thread.
+  scoped_ptr<Blacklist> blacklist_;
+
+  DISALLOW_COPY_AND_ASSIGN(HostBlacklistManager);
+};
+
+}  // namespace policy
+
+#endif  // CHROME_BROWSER_POLICY_HOST_BLACKLIST_MANAGER_H_