Implement loading blacklists from extensions....

chrome/browser/privacy_blacklist/blacklist_manager.cc

 // Copyright (c) 2009 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.
 
 #include "chrome/browser/privacy_blacklist/blacklist_manager.h"
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/task.h"
 #include "base/thread.h"
@@ skipping 17 matching lines @@
     DCHECK(original_loop_);
     manager->AddRef();
   }
 
   ~BlacklistManagerTask() {
     original_loop_->ReleaseSoon(FROM_HERE, manager_);
   }
 
  protected:
   BlacklistManager* blacklist_manager() const { return manager_; }
-  
+
   MessageLoop* original_loop_;
 
  private:
   BlacklistManager* manager_;
 
   DISALLOW_COPY_AND_ASSIGN(BlacklistManagerTask);
 };
 
 BlacklistPathProvider::~BlacklistPathProvider() {
 }
 
 class BlacklistManager::CompileBlacklistTask : public BlacklistManagerTask {
  public:
   CompileBlacklistTask(BlacklistManager* manager,
                        const FilePath& destination_blacklist,
                        const std::vector<FilePath>& source_blacklists)
       : BlacklistManagerTask(manager),
         destination_blacklist_(destination_blacklist),
         source_blacklists_(source_blacklists) {
   }
 
   virtual void Run() {
     bool success = true;
-    
+
     Blacklist blacklist;
     std::string error_string;
 
     for (std::vector<FilePath>::const_iterator i = source_blacklists_.begin();
          i != source_blacklists_.end(); ++i) {
       if (!BlacklistIO::ReadText(&blacklist, *i, &error_string)) {
         success = false;
         break;
       }
     }
@@ skipping 27 matching lines @@
         compiled_blacklist_(compiled_blacklist),
         transient_blacklists_(transient_blacklists) {
   }
 
   virtual void Run() {
     scoped_ptr<Blacklist> blacklist(new Blacklist);
     if (!BlacklistIO::ReadBinary(blacklist.get(), compiled_blacklist_)) {
       ReportReadResult(NULL);
       return;
     }
-    
+
     std::string error_string;
     std::vector<FilePath>::const_iterator i;
     for (i = transient_blacklists_.begin();
          i != transient_blacklists_.end(); ++i) {
       if (!BlacklistIO::ReadText(blacklist.get(), *i, &error_string)) {
         ReportReadResult(NULL);
         return;
       }
     }
-    
+
     ReportReadResult(blacklist.release());
   }
 
  private:
   void ReportReadResult(Blacklist* blacklist) {
     original_loop_->PostTask(
         FROM_HERE, NewRunnableMethod(blacklist_manager(),
                                      &BlacklistManager::OnBlacklistReadFinished,
                                      blacklist));
   }
-  
+
   FilePath compiled_blacklist_;
   std::vector<FilePath> transient_blacklists_;
 
   DISALLOW_COPY_AND_ASSIGN(ReadBlacklistTask);
 };
 
 BlacklistManager::BlacklistManager(Profile* profile,
                                    BlacklistPathProvider* path_provider,
                                    base::Thread* backend_thread)
     : first_read_finished_(false),
       profile_(profile),
       compiled_blacklist_path_(
         profile->GetPath().Append(chrome::kPrivacyBlacklistFileName)),
       path_provider_(path_provider),
       backend_thread_(backend_thread) {
   registrar_.Add(this,
-                 NotificationType::BLACKLIST_PATH_PROVIDER_UPDATED,
+                 NotificationType::EXTENSION_LOADED,
+                 Source<Profile>(profile));
+  registrar_.Add(this,
+                 NotificationType::EXTENSION_UNLOADED,
                  Source<Profile>(profile));
   ReadBlacklist();
 }
 
 void BlacklistManager::Observe(NotificationType type,
                                const NotificationSource& source,
                                const NotificationDetails& details) {
-  DCHECK(type == NotificationType::BLACKLIST_PATH_PROVIDER_UPDATED);
-  CompileBlacklist();
+  switch (type.value) {
+    case NotificationType::EXTENSION_LOADED:
+    case NotificationType::EXTENSION_UNLOADED:
+      CompileBlacklist();
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
 }
 
 void BlacklistManager::CompileBlacklist() {
   DCHECK(CalledOnValidThread());
 
   RunTaskOnBackendThread(new CompileBlacklistTask(
       this, compiled_blacklist_path_,
       path_provider_->GetPersistentBlacklistPaths()));
 }
 
 void BlacklistManager::ReadBlacklist() {
   DCHECK(CalledOnValidThread());
-  
+
   RunTaskOnBackendThread(new ReadBlacklistTask(
       this, compiled_blacklist_path_,
       path_provider_->GetTransientBlacklistPaths()));
 }
 
 void BlacklistManager::OnBlacklistCompilationFinished(bool success) {
   DCHECK(CalledOnValidThread());
-  
+
   if (success) {
     ReadBlacklist();
   } else {
     string16 error_message(ASCIIToUTF16("Blacklist compilation failed."));
     NotificationService::current()->Notify(
         NotificationType::BLACKLIST_MANAGER_ERROR,
         Source<Profile>(profile_),
         Details<string16>(&error_message));
   }
 }
 
 void BlacklistManager::OnBlacklistReadFinished(Blacklist* blacklist) {
   DCHECK(CalledOnValidThread());
-  
+
   if (!blacklist) {
     if (!first_read_finished_) {
       // If we're loading for the first time, the compiled blacklist could
       // just not exist. Try compiling it once.
       first_read_finished_ = true;
       CompileBlacklist();
     } else {
       string16 error_message(ASCIIToUTF16("Blacklist read failed."));
       NotificationService::current()->Notify(
           NotificationType::BLACKLIST_MANAGER_ERROR,
           Source<Profile>(profile_),
           Details<string16>(&error_message));
     }
     return;
   }
   first_read_finished_ = true;
   compiled_blacklist_.reset(blacklist);
-  
+
   NotificationService::current()->Notify(
       NotificationType::BLACKLIST_MANAGER_BLACKLIST_READ_FINISHED,
       Source<Profile>(profile_),
       Details<Blacklist>(blacklist));
 }
 
 void BlacklistManager::RunTaskOnBackendThread(Task* task) {
   if (backend_thread_) {
     backend_thread_->message_loop()->PostTask(FROM_HERE, task);
   } else {
     task->Run();
     delete task;
   }
 }