Redesigned and refactored ScopedMTPDeviceMapEntry, MTPDeviceMapService & MTPDeviceDelegate classes.

chrome/browser/media_gallery/mtp_device_delegate_impl_linux.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/media_gallery/mtp_device_delegate_impl_linux.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/sequenced_task_runner.h"
 #include "base/sequenced_task_runner_helpers.h"
+#include "base/synchronization/cancellation_flag.h"
 #include "base/string_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/media_transfer_protocol/media_transfer_protocol_manager.h"
 #include "chrome/browser/media_transfer_protocol/mtp_file_entry.pb.h"
-#include "chrome/common/chrome_notification_types.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/notification_service.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
 using base::Bind;
 using base::PlatformFileError;
 using base::PlatformFileInfo;
 using base::SequencedTaskRunner;
 using base::Time;
 using content::BrowserThread;
 using fileapi::FileSystemFileUtil;
 
@@ skipping 32 matching lines @@
   DCHECK(mtp_device_mgr);
   return mtp_device_mgr;
 }
 
 // Does nothing.
 // This method is used to handle the results of
 // MediaTransferProtocolManager::CloseStorage method call.
 void DoNothing(bool error) {
 }
 
+// Closes the device storage on the UI thread.
+void CloseStorageOnUIThread(const std::string& device_handle) {
+  DCHECK(!device_handle.empty());
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  GetMediaTransferProtocolManager()->CloseStorage(device_handle,
+                                                  Bind(&DoNothing));
+}
+
 // Returns the device relative file path given |file_path|.
 // E.g.: If the |file_path| is "/usb:2,2:12345/DCIM" and |registered_dev_path|
 // is "/usb:2,2:12345", this function returns the device relative path which is
 // "/DCIM".
 std::string GetDeviceRelativePath(const std::string& registered_dev_path,
                                   const std::string& file_path) {
   DCHECK(!registered_dev_path.empty());
   DCHECK(!file_path.empty());
 
   std::string actual_file_path;
@@ skipping 34 matching lines @@
     if (on_shutdown_event_->IsSignaled()) {
       // Process is in shutdown mode.
       // Do not post any task on |media_task_runner_|.
       return;
     }
 
     DCHECK(media_task_runner_->RunsTasksOnCurrentThread());
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             Bind(&OpenStorageWorker::DoWorkOnUIThread, this));
     on_task_completed_event_->Wait();
+
+    if (on_shutdown_event_->IsSignaled())
+      cancel_tasks_flag_.Set();
   }
 
   // Returns a device handle string if the OpenStorage() request was
   // successfully completed or an empty string otherwise.
   const std::string& device_handle() const { return device_handle_; }
 
   // Returns the |media_task_runner_| associated with this worker object.
   // This function is exposed for WorkerDeleter struct to access the
   // |media_task_runner_|.
   SequencedTaskRunner* media_task_runner() const {
     return media_task_runner_.get();
   }
 
  private:
   friend struct WorkerDeleter<OpenStorageWorker>;
   friend class DeleteHelper<OpenStorageWorker>;
   friend class RefCountedThreadSafe<OpenStorageWorker,
                                     OpenStorageWorkerDeleter>;
 
   // Destructed via OpenStorageWorkerDeleter struct.
   virtual ~OpenStorageWorker() {
     // This object must be destructed on |media_task_runner_|.
   }
 
   // Dispatches a request to MediaTransferProtocolManager to open the MTP
   // storage for communication. This is called on UI thread.
   void DoWorkOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (cancel_tasks_flag_.IsSet())
+      return;
 
     GetMediaTransferProtocolManager()->OpenStorage(
         storage_name_, mtpd::kReadOnlyMode,
         Bind(&OpenStorageWorker::OnDidWorkOnUIThread, this));
   }
 
   // Query callback for DoWorkOnUIThread(). |error| is set to true if the device
   // did not open successfully. This function signals to unblock
   // |media_task_runner_|.
   void OnDidWorkOnUIThread(const std::string& device_handle, bool error) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!error)
       device_handle_ = device_handle;
-    on_task_completed_event_->Signal();
+    if (!cancel_tasks_flag_.IsSet())
+      on_task_completed_event_->Signal();
   }
 
   // Stores the storage name to open the device.
   const std::string storage_name_;
 
   // Stores a reference to |media_task_runner_| to destruct this object on the
   // correct thread.
   scoped_refptr<SequencedTaskRunner> media_task_runner_;
 
   // |media_task_runner_| can wait on this event until the required operation
   // is complete.
   // TODO(kmadhusu): Remove this WaitableEvent after modifying the
   // DeviceMediaFileUtil functions as asynchronous functions.
   WaitableEvent* on_task_completed_event_;
 
   // Stores a reference to waitable event associated with the shut down message.
   WaitableEvent* on_shutdown_event_;
 
   // Stores the result of OpenStorage() request.
   std::string device_handle_;
 
+  // Set to ignore the request results. This will be set when
+  // MTPDeviceDelegateImplLinux object is about to be deleted.
+  // |on_task_completed_event_| and |on_shutdown_event_| should not be
+  // dereferenced when this is set.
+  base::CancellationFlag cancel_tasks_flag_;
+
   DISALLOW_COPY_AND_ASSIGN(OpenStorageWorker);
 };
 
 // Worker class to get media device file information given a |path|.
 class GetFileInfoWorker
     : public RefCountedThreadSafe<GetFileInfoWorker, GetFileInfoWorkerDeleter> {
  public:
   // Constructed on |media_task_runner_| thread.
   GetFileInfoWorker(const std::string& handle,
                     const std::string& path,
@@ skipping 15 matching lines @@
   void Run() {
     if (on_shutdown_event_->IsSignaled()) {
       // Process is in shutdown mode.
       // Do not post any task on |media_task_runner_|.
       return;
     }
 
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             Bind(&GetFileInfoWorker::DoWorkOnUIThread, this));
     on_task_completed_event_->Wait();
+
+    if (on_shutdown_event_->IsSignaled())
+      cancel_tasks_flag_.Set();
   }
 
   // Returns GetFileInfo() result and fills in |file_info| with requested file
   // entry details.
   PlatformFileError get_file_info(PlatformFileInfo* file_info) const {
     if (file_info)
       *file_info = file_entry_info_;
     return error_;
   }
 
@@ skipping 12 matching lines @@
 
   // Destructed via GetFileInfoWorkerDeleter.
   virtual ~GetFileInfoWorker() {
     // This object must be destructed on |media_task_runner_|.
   }
 
   // Dispatches a request to MediaTransferProtocolManager to get file
   // information.
   void DoWorkOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (cancel_tasks_flag_.IsSet())
+      return;
 
     GetMediaTransferProtocolManager()->GetFileInfoByPath(
         device_handle_, path_,
         Bind(&GetFileInfoWorker::OnDidWorkOnUIThread, this));
   }
 
   // Query callback for DoWorkOnUIThread(). On success, |file_entry| has media
   // file information. On failure, |error| is set to true. This function signals
   // to unblock |media_task_runner_|.
   void OnDidWorkOnUIThread(const MtpFileEntry& file_entry, bool error) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (error) {
       error_ = base::PLATFORM_FILE_ERROR_NOT_FOUND;
     } else {
       file_entry_info_.size = file_entry.file_size();
       file_entry_info_.is_directory =
           file_entry.file_type() == MtpFileEntry::FILE_TYPE_FOLDER;
       file_entry_info_.is_symbolic_link = false;
       file_entry_info_.last_modified =
           base::Time::FromTimeT(file_entry.modification_time());
       file_entry_info_.last_accessed =
           base::Time::FromTimeT(file_entry.modification_time());
       file_entry_info_.creation_time = base::Time();
     }
-    on_task_completed_event_->Signal();
+    if (!cancel_tasks_flag_.IsSet())
+      on_task_completed_event_->Signal();
   }
 
   // Stores the device handle to query the device.
   const std::string device_handle_;
 
   // Stores the requested media device file path.
   const std::string path_;
 
   // Stores a reference to |media_task_runner_| to destruct this object on the
   // correct thread.
   scoped_refptr<SequencedTaskRunner> media_task_runner_;
 
   // Stores the result of GetFileInfo().
   PlatformFileError error_;
 
   // Stores the media file entry information.
   PlatformFileInfo file_entry_info_;
 
   // |media_task_runner_| can wait on this event until the required operation
   // is complete.
   // TODO(kmadhusu): Remove this WaitableEvent after modifying the
   // DeviceMediaFileUtil functions as asynchronous functions.
   WaitableEvent* on_task_completed_event_;
 
   // Stores a reference to waitable event associated with the shut down message.
   WaitableEvent* on_shutdown_event_;
 
+  // Set to ignore the request results. This will be set when
+  // MTPDeviceDelegateImplLinux object is about to be deleted.
+  // |on_task_completed_event_| and |on_shutdown_event_| should not be
+  // dereferenced when this is set.
+  base::CancellationFlag cancel_tasks_flag_;
+
   DISALLOW_COPY_AND_ASSIGN(GetFileInfoWorker);
 };
 
 // Worker class to read media device file data given a file |path|.
 class ReadFileWorker
     : public RefCountedThreadSafe<ReadFileWorker, ReadFileWorkerDeleter> {
  public:
   // Constructed on |media_task_runner_| thread.
   ReadFileWorker(const std::string& handle,
                  const std::string& path,
@@ skipping 14 matching lines @@
   void Run() {
     if (on_shutdown_event_->IsSignaled()) {
       // Process is in shutdown mode.
       // Do not post any task on |media_task_runner_|.
       return;
     }
 
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             Bind(&ReadFileWorker::DoWorkOnUIThread, this));
     on_task_completed_event_->Wait();
+    if (on_shutdown_event_->IsSignaled())
+      cancel_tasks_flag_.Set();
   }
 
   // Returns the media file contents received by ReadFileByPath() callback
   // function.
   const std::string& data() const { return data_; }
 
   // Returns the |media_task_runner_| associated with this worker object.
   // This function is exposed for WorkerDeleter struct to access the
   // |media_task_runner_|.
   SequencedTaskRunner* media_task_runner() const {
     return media_task_runner_.get();
   }
 
  private:
   friend struct WorkerDeleter<ReadFileWorker>;
   friend class DeleteHelper<ReadFileWorker>;
   friend class RefCountedThreadSafe<ReadFileWorker, ReadFileWorkerDeleter>;
 
   // Destructed via ReadFileWorkerDeleter.
   virtual ~ReadFileWorker() {
     // This object must be destructed on |media_task_runner_|.
   }
 
   // Dispatches a request to MediaTransferProtocolManager to get the media file
   // contents.
   void DoWorkOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (cancel_tasks_flag_.IsSet())
+      return;
+
     GetMediaTransferProtocolManager()->ReadFileByPath(
       device_handle_, path_, Bind(&ReadFileWorker::OnDidWorkOnUIThread, this));
   }
 
   // Query callback for DoWorkOnUIThread(). On success, |data| has the media
   // file contents. On failure, |error| is set to true. This function signals
   // to unblock |media_task_runner_|.
   void OnDidWorkOnUIThread(const std::string& data, bool error) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!error) {
       // TODO(kmadhusu): Data could be really huge. Consider passing data by
       // pointer/ref rather than by value here to avoid an extra data copy.
       data_ = data;
     }
-    on_task_completed_event_->Signal();
+    if (!cancel_tasks_flag_.IsSet())
+      on_task_completed_event_->Signal();
   }
 
   // Stores the device unique identifier to query the device.
   const std::string device_handle_;
 
   // Stores the media device file path.
   const std::string path_;
 
   // Stores a reference to |media_task_runner_| to destruct this object on the
   // correct thread.
   scoped_refptr<SequencedTaskRunner> media_task_runner_;
 
   // Stores the result of ReadFileByPath() callback.
   std::string data_;
 
   // |media_task_runner_| can wait on this event until the required operation
   // is complete.
   // TODO(kmadhusu): Remove this WaitableEvent after modifying the
   // DeviceMediaFileUtil functions as asynchronous functions.
   WaitableEvent* on_task_completed_event_;
 
   // Stores a reference to waitable event associated with the shut down message.
   WaitableEvent* on_shutdown_event_;
 
+  // Set to ignore the request results. This will be set when
+  // MTPDeviceDelegateImplLinux object is about to be deleted.
+  // |on_task_completed_event_| and |on_shutdown_event_| should not be
+  // dereferenced when this is set.
+  base::CancellationFlag cancel_tasks_flag_;
+
   DISALLOW_COPY_AND_ASSIGN(ReadFileWorker);
 };
 
 // Worker class to read directory contents. Device is already opened for
 // communication.
 class ReadDirectoryWorker
     : public RefCountedThreadSafe<ReadDirectoryWorker,
                                   ReadDirectoryWorkerDeleter> {
  public:
   // Construct a worker object given the directory |path|. This object is
@@ skipping 35 matching lines @@
   void Run() {
     if (on_shutdown_event_->IsSignaled()) {
       // Process is in shutdown mode.
       // Do not post any task on |media_task_runner_|.
       return;
     }
 
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             Bind(&ReadDirectoryWorker::DoWorkOnUIThread, this));
     on_task_completed_event_->Wait();
+    if (on_shutdown_event_->IsSignaled())
+      cancel_tasks_flag_.Set();
   }
 
   // Returns the directory entries for the given directory path.
   const std::vector<MtpFileEntry>& get_file_entries() const {
     return file_entries_;
   }
 
   // Returns the |media_task_runner_| associated with this worker object.
   // This function is exposed for WorkerDeleter struct to access the
   // |media_task_runner_|.
   SequencedTaskRunner* media_task_runner() const {
     return media_task_runner_.get();
   }
 
  private:
   friend struct WorkerDeleter<ReadDirectoryWorker>;
   friend class DeleteHelper<ReadDirectoryWorker>;
   friend class RefCountedThreadSafe<ReadDirectoryWorker,
                                     ReadDirectoryWorkerDeleter>;
 
   // Destructed via ReadDirectoryWorkerDeleter.
   virtual ~ReadDirectoryWorker() {
     // This object must be destructed on |media_task_runner_|.
   }
 
   // Dispatches a request to MediaTransferProtocolManager to read the directory
   // entries. This is called on UI thread.
   void DoWorkOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (cancel_tasks_flag_.IsSet())
+      return;
 
     if (!dir_path_.empty()) {
       GetMediaTransferProtocolManager()->ReadDirectoryByPath(
           device_handle_, dir_path_,
           Bind(&ReadDirectoryWorker::OnDidWorkOnUIThread, this));
     } else {
       GetMediaTransferProtocolManager()->ReadDirectoryById(
           device_handle_, dir_entry_id_,
           Bind(&ReadDirectoryWorker::OnDidWorkOnUIThread, this));
     }
   }
 
   // Query callback for DoWorkOnUIThread(). On success, |file_entries| has the
   // directory file entries. |error| is true if there was an error. This
   // function signals to unblock |media_task_runner_|.
   void OnDidWorkOnUIThread(const std::vector<MtpFileEntry>& file_entries,
                            bool error) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!error)
       file_entries_ = file_entries;
-    on_task_completed_event_->Signal();
+    if (!cancel_tasks_flag_.IsSet())
+      on_task_completed_event_->Signal();
   }
 
   // Stores the device handle to communicate with storage device.
   const std::string device_handle_;
 
   // Stores the directory path whose contents needs to be listed.
   const std::string dir_path_;
 
   // Stores the directory entry id whose contents needs to be listed.
   const uint32_t dir_entry_id_;
 
   // Stores a reference to |media_task_runner_| to destruct this object on the
   // correct thread.
   scoped_refptr<SequencedTaskRunner> media_task_runner_;
 
   // |media_task_runner_| can wait on this event until the required operation
   // is complete.
   // TODO(kmadhusu): Remove this WaitableEvent after modifying the
   // DeviceMediaFileUtil functions as asynchronous functions.
   WaitableEvent* on_task_completed_event_;
 
   // Stores a reference to waitable event associated with the shut down message.
   WaitableEvent* on_shutdown_event_;
 
   // Stores the result of read directory request.
   std::vector<MtpFileEntry> file_entries_;
 
+  // Set to ignore the request results. This will be set when
+  // MTPDeviceDelegateImplLinux object is about to be deleted.
+  // |on_task_completed_event_| and |on_shutdown_event_| should not be
+  // dereferenced when this is set.
+  base::CancellationFlag cancel_tasks_flag_;
+
   DISALLOW_COPY_AND_ASSIGN(ReadDirectoryWorker);
 };
 
 // Simply enumerate each files from a given file entry list.
 // Used to enumerate top-level files of an media file system.
 class MediaFileEnumerator : public FileSystemFileUtil::AbstractFileEnumerator {
  public:
   explicit MediaFileEnumerator(const std::vector<MtpFileEntry>& entries)
       : file_entries_(entries),
         file_entry_iter_(file_entries_.begin()) {
@@ skipping 152 matching lines @@
     const std::string& device_location)
     : device_path_(device_location),
       on_task_completed_event_(false, false),
       on_shutdown_event_(true, false) {
   CHECK(!device_path_.empty());
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   base::SequencedWorkerPool* pool = BrowserThread::GetBlockingPool();
   base::SequencedWorkerPool::SequenceToken media_sequence_token =
       pool->GetNamedSequenceToken("media-task-runner");
   media_task_runner_ = pool->GetSequencedTaskRunner(media_sequence_token);
-  registrar_.Add(this, chrome::NOTIFICATION_APP_TERMINATING,
-                 content::NotificationService::AllSources());
-
-  DCHECK(media_task_runner_);
-}
-
-MTPDeviceDelegateImplLinux::~MTPDeviceDelegateImplLinux() {
-  registrar_.RemoveAll();
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  GetMediaTransferProtocolManager()->CloseStorage(device_handle_,
-                                                  Bind(&DoNothing));
 }
 
 PlatformFileError MTPDeviceDelegateImplLinux::GetFileInfo(
     const FilePath& file_path,
     PlatformFileInfo* file_info) {
   if (!LazyInit())
     return base::PLATFORM_FILE_ERROR_FAILED;
 
   scoped_refptr<GetFileInfoWorker> worker(new GetFileInfoWorker(
       device_handle_, GetDeviceRelativePath(device_path_, file_path.value()),
@@ skipping 57 matching lines @@
   // Modify the last modified time to null. This prevents the time stamp
   // verfication in LocalFileStreamReader.
   file_info->last_modified = base::Time();
   return error;
 }
 
 SequencedTaskRunner* MTPDeviceDelegateImplLinux::GetMediaTaskRunner() {
   return media_task_runner_.get();
 }
 
-void MTPDeviceDelegateImplLinux::DeleteOnCorrectThread() const {
-  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
-    BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, this);
-    return;
-  }
-  delete this;
+void MTPDeviceDelegateImplLinux::CancelPendingTasksAndDeleteDelegate() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  // Caution: This function is called on the IO thread. Access only the thread
+  // safe member variables in this function. Do all the clean up operations in
+  // DeleteDelegateOnTaskRunner().
+  on_shutdown_event_.Signal();
+  on_task_completed_event_.Signal();
+  media_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&MTPDeviceDelegateImplLinux::DeleteDelegateOnTaskRunner,
+                 base::Unretained(this)));
 }
 
-void MTPDeviceDelegateImplLinux::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  DCHECK_EQ(chrome::NOTIFICATION_APP_TERMINATING, type);
-  on_shutdown_event_.Signal();
-  on_task_completed_event_.Signal();
+base::WeakPtr<fileapi::MTPDeviceDelegate> MTPDeviceDelegateImplLinux::
+    GetAsWeakPtrOnIOThread() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  base::WeakPtr<fileapi::MTPDeviceDelegate> delegate = AsWeakPtr();
+  // This function is called on the IO thread but the member functions are
+  // accessed on |media_task_runner_|. Therefore, detach from the the current
+  // thread.
+  DetachFromThread();
+  return delegate;
+}
+
+MTPDeviceDelegateImplLinux::~MTPDeviceDelegateImplLinux() {
+  DCHECK(media_task_runner_->RunsTasksOnCurrentThread());
+  // Do all the clean up operations on DeleteDelegateOnTaskRunner().
 }
 
 bool MTPDeviceDelegateImplLinux::LazyInit() {
   DCHECK(media_task_runner_);
   DCHECK(media_task_runner_->RunsTasksOnCurrentThread());
 
   if (!device_handle_.empty())
     return true;  // Already successfully initialized.
 
   std::string storage_name;
   RemoveChars(device_path_, kRootPath, &storage_name);
   DCHECK(!storage_name.empty());
   scoped_refptr<OpenStorageWorker> worker(new OpenStorageWorker(
       storage_name, media_task_runner_, &on_task_completed_event_,
       &on_shutdown_event_));
   worker->Run();
   device_handle_ = worker->device_handle();
   return !device_handle_.empty();
 }
 
+void MTPDeviceDelegateImplLinux::DeleteDelegateOnTaskRunner() {
+  DCHECK(media_task_runner_->RunsTasksOnCurrentThread());
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                          Bind(&CloseStorageOnUIThread, device_handle_));
+  delete this;
+}
+
 }  // namespace chrome