Switch to using FilePathWatcher::Callback instead of FilePathWatcher::Delegate.

chrome/browser/user_style_sheet_watcher.cc

 // Copyright (c) 2012 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/user_style_sheet_watcher.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 26 matching lines @@
 //             V                                 |
 //  .----------------------.                     |
 //  | UserStyleSheetLoader |<--------------------'
 //  '----------------------'
 //
 // FilePathWatcher's reference to UserStyleSheetLoader is used for delivering
 // the change notifications. Since they happen asynchronously,
 // UserStyleSheetWatcher and its FilePathWatcher may be destroyed while a
 // callback to UserStyleSheetLoader is in progress, in which case the
 // UserStyleSheetLoader object outlives the watchers.
-class UserStyleSheetLoader : public FilePathWatcher::Delegate {
+class UserStyleSheetLoader
+    : public base::RefCountedThreadSafe<UserStyleSheetLoader> {
  public:
   UserStyleSheetLoader();
 
   GURL user_style_sheet() const {
     return user_style_sheet_;
   }
 
   // Load the user style sheet on the file thread and convert it to a
   // base64 URL.  Posts the base64 URL back to the UI thread.
   void LoadStyleSheet(const FilePath& style_sheet_file);
 
   // Send out a notification if the stylesheet has already been loaded.
   void NotifyLoaded();
 
-  // FilePathWatcher::Delegate interface
-  virtual void OnFilePathChanged(const FilePath& path);
+  // FilePathWatcher::Callback method:
+  void NotifyPathChanged(const FilePath& path, bool error);
 
  private:
-  virtual ~UserStyleSheetLoader() {}
+  friend class base::RefCountedThreadSafe<UserStyleSheetLoader>;
+  ~UserStyleSheetLoader() {}
 
   // Called on the UI thread after the stylesheet has loaded.
   void SetStyleSheet(const GURL& url);
 
   // The user style sheet as a base64 data:// URL.
   GURL user_style_sheet_;
 
   // Whether the stylesheet has been loaded.
   bool has_loaded_;
 
   DISALLOW_COPY_AND_ASSIGN(UserStyleSheetLoader);
 };
 
 UserStyleSheetLoader::UserStyleSheetLoader()
     : has_loaded_(false) {
 }
 
 void UserStyleSheetLoader::NotifyLoaded() {
   if (has_loaded_) {
     content::NotificationService::current()->Notify(
         chrome::NOTIFICATION_USER_STYLE_SHEET_UPDATED,
         content::Source<UserStyleSheetLoader>(this),
         content::NotificationService::NoDetails());
   }
 }
 
-void UserStyleSheetLoader::OnFilePathChanged(const FilePath& path) {
-  LoadStyleSheet(path);
+void UserStyleSheetLoader::NotifyPathChanged(const FilePath& path, bool error) {
+  if (!error)
+    LoadStyleSheet(path);
 }
 
 void UserStyleSheetLoader::LoadStyleSheet(const FilePath& style_sheet_file) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   // We keep the user style sheet in a subdir so we can watch for changes
   // to the file.
   FilePath style_sheet_dir = style_sheet_file.DirName();
   if (!file_util::DirectoryExists(style_sheet_dir)) {
     if (!file_util::CreateDirectory(style_sheet_dir))
       return;
@@ skipping 50 matching lines @@
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
                             base::Bind(&UserStyleSheetWatcher::Init, this));
     return;
   }
 
   if (!file_watcher_.get()) {
     file_watcher_.reset(new FilePathWatcher);
     FilePath style_sheet_file = profile_path_.AppendASCII(kStyleSheetDir)
                                              .AppendASCII(kUserStyleSheetFile);
     if (!file_watcher_->Watch(
-        style_sheet_file,
-        loader_.get())) {
+            style_sheet_file,
+            false,
+            base::Bind(&UserStyleSheetLoader::NotifyPathChanged,
+                       loader_.get()))) {
       LOG(ERROR) << "Failed to setup watch for " << style_sheet_file.value();
     }
     loader_->LoadStyleSheet(style_sheet_file);
   }
 }
 
 GURL UserStyleSheetWatcher::user_style_sheet() const {
   return loader_->user_style_sheet();
 }
 
 void UserStyleSheetWatcher::Observe(int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(type == content::NOTIFICATION_WEB_CONTENTS_RENDER_VIEW_HOST_CREATED);
   if (profile_->IsSameProfile(Profile::FromBrowserContext(
           content::Source<WebContents>(source)->GetBrowserContext()))) {
     loader_->NotifyLoaded();
     registrar_.RemoveAll();
   }
 }
 
 void UserStyleSheetWatcher::ShutdownOnUIThread() {
   registrar_.RemoveAll();
 }