drive: Fix lifetime model of FileBrowserEventRouter

chrome/browser/chromeos/extensions/file_browser_event_router.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/chromeos/extensions/file_browser_event_router.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
@@ skipping 214 matching lines @@
       base::Bind(&DirectoryExistsOnBlockingPool,
                  directory_path,
                  success_callback,
                  failure_callback));
 };
 
 }  // namespace
 
 FileBrowserEventRouter::FileBrowserEventRouter(
     Profile* profile)
-    : weak_factory_(this),
-      notifications_(new FileBrowserNotifications(profile)),
+    : notifications_(new FileBrowserNotifications(profile)),
       pref_change_registrar_(new PrefChangeRegistrar),
       profile_(profile),
       num_remote_update_requests_(0),
-      shift_pressed_(false) {
+      shift_pressed_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  // Bind a weak reference back to |this| to avoid memory errors in case we
-  // shut down while a callback is in flight.
   file_watcher_callback_ =
       base::Bind(&RelayFileWatcherCallbackToUIThread,
           base::Bind(&FileBrowserEventRouter::HandleFileWatchNotification,
                      weak_factory_.GetWeakPtr()));
 
   // Listen for the Shift modifier's state changes.
   chromeos::SystemKeyEventListener* key_event_listener =
       chromeos::SystemKeyEventListener::GetInstance();
   if (key_event_listener)
     key_event_listener->AddModifiersObserver(this);
@@ skipping 62 matching lines @@
     chromeos::ConnectivityStateHelper::Get()->
         AddNetworkManagerObserver(this);
   }
   suspend_state_delegate_.reset(new SuspendStateDelegateImpl());
 
   pref_change_registrar_->Init(profile_->GetPrefs());
 
   pref_change_registrar_->Add(
       prefs::kExternalStorageDisabled,
       base::Bind(&FileBrowserEventRouter::OnExternalStorageDisabledChanged,
-                 base::Unretained(this)));
+                 weak_factory_.GetWeakPtr()));
 
   base::Closure callback =
       base::Bind(&FileBrowserEventRouter::OnFileBrowserPrefsChanged,
-                 base::Unretained(this));
+                 weak_factory_.GetWeakPtr());
   pref_change_registrar_->Add(prefs::kDisableDriveOverCellular, callback);
   pref_change_registrar_->Add(prefs::kDisableDriveHostedFiles, callback);
   pref_change_registrar_->Add(prefs::kDisableDrive, callback);
   pref_change_registrar_->Add(prefs::kUse24HourClock, callback);
 }
 
 // File watch setup routines.
 bool FileBrowserEventRouter::AddFileWatch(
     const base::FilePath& local_path,
     const base::FilePath& virtual_path,
     const std::string& extension_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   base::AutoLock lock(lock_);
   base::FilePath watch_path = local_path;
   bool is_remote_watch = false;
   // Tweak watch path for remote sources - we need to drop leading /special
   // directory from there in order to be able to pair these events with
   // their change notifications.
   if (drive::util::GetSpecialRemoteRootPath().IsParent(watch_path)) {
     watch_path = drive::util::ExtractDrivePath(watch_path);
     is_remote_watch = true;
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&FileBrowserEventRouter::HandleRemoteUpdateRequestOnUIThread,
-                   this, true));
+                   weak_factory_.GetWeakPtr(), true));

[satorux1, 2013/04/08 06:34:36]

Hmm, this is also broken, as  weak_factory_.GetWeakPtr() is called from FILE
thread!

   }
 
   WatcherMap::iterator iter = file_watchers_.find(watch_path);
   if (iter == file_watchers_.end()) {
     scoped_ptr<FileWatcherExtensions>
         watch(new FileWatcherExtensions(virtual_path,
                                         extension_id,
                                         is_remote_watch));
 
     if (watch->Watch(watch_path, file_watcher_callback_))
@@ skipping 14 matching lines @@
   base::AutoLock lock(lock_);
   base::FilePath watch_path = local_path;
   // Tweak watch path for remote sources - we need to drop leading /special
   // directory from there in order to be able to pair these events with
   // their change notifications.
   if (drive::util::GetSpecialRemoteRootPath().IsParent(watch_path)) {
     watch_path = drive::util::ExtractDrivePath(watch_path);
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(&FileBrowserEventRouter::HandleRemoteUpdateRequestOnUIThread,
-                   this, false));
+                   weak_factory_.GetWeakPtr(), false));
   }
   WatcherMap::iterator iter = file_watchers_.find(watch_path);
   if (iter == file_watchers_.end())
     return;
   // Remove the renderer process for this watch.
   iter->second->RemoveExtension(extension_id);
   if (iter->second->GetRefCount() == 0) {
     delete iter->second;
     file_watchers_.erase(iter);
   }
@@ skipping 568 matching lines @@
 }
 
 bool FileBrowserEventRouter::FileWatcherExtensions::Watch(
     const base::FilePath& path,
     const base::FilePathWatcher::Callback& callback) {
   if (is_remote_file_system_)
     return true;
 
   return file_watcher_->Watch(path, false, callback);
 }