Media Galleries: Another round of MTPDeviceDelegateImplLinux cleanup.

chrome/browser/media_galleries/linux/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_galleries/linux/mtp_device_delegate_impl_linux.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
@@ skipping 241 matching lines @@
               success_callback,
               error_callback),
           base::Bind(&MTPDeviceDelegateImplLinux::HandleDeviceFileError,
                      weak_ptr_factory_.GetWeakPtr(),
                      error_callback));
   EnsureInitAndRunTask(PendingTaskInfo(FROM_HERE, call_closure));
 }
 
 void MTPDeviceDelegateImplLinux::CreateSnapshotFile(
     const base::FilePath& device_file_path,
-    const base::FilePath& snapshot_file_path,
+    const base::FilePath& local_path,
     const CreateSnapshotFileSuccessCallback& success_callback,
     const ErrorCallback& error_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!device_file_path.empty());
-  DCHECK(!snapshot_file_path.empty());
+  DCHECK(!local_path.empty());
   std::string device_file_relative_path =
       GetDeviceRelativePath(device_path_, device_file_path);
   scoped_ptr<SnapshotRequestInfo> request_info(
       new SnapshotRequestInfo(device_file_relative_path,
-                              snapshot_file_path,
+                              local_path,
                               success_callback,
                               error_callback));
   base::Closure call_closure =
       base::Bind(
           &GetFileInfoOnUIThread,
           storage_name_,
           device_file_relative_path,
           base::Bind(
               &MTPDeviceDelegateImplLinux::OnDidGetFileInfoToCreateSnapshotFile,
               weak_ptr_factory_.GetWeakPtr(),
@@ skipping 63 matching lines @@
                    base::Bind(&MTPDeviceDelegateImplLinux::OnInitCompleted,
                               weak_ptr_factory_.GetWeakPtr())));
   }
 }
 
 void MTPDeviceDelegateImplLinux::WriteDataIntoSnapshotFile(
     const base::File::Info& file_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(current_snapshot_request_info_.get());
   DCHECK_GT(file_info.size, 0);
-  task_in_progress_ = true;
+  DCHECK(task_in_progress_);
   SnapshotRequestInfo request_info(
       current_snapshot_request_info_->device_file_path,
       current_snapshot_request_info_->snapshot_file_path,
       base::Bind(
           &MTPDeviceDelegateImplLinux::OnDidWriteDataIntoSnapshotFile,
           weak_ptr_factory_.GetWeakPtr()),
       base::Bind(
           &MTPDeviceDelegateImplLinux::OnWriteDataIntoSnapshotFileError,
           weak_ptr_factory_.GetWeakPtr()));
 
   base::Closure task_closure = base::Bind(&WriteDataIntoSnapshotFileOnUIThread,
                                           storage_name_,
                                           request_info,
                                           file_info);
   content::BrowserThread::PostTask(content::BrowserThread::UI,
                                    FROM_HERE,
                                    task_closure);
 }
 
+void MTPDeviceDelegateImplLinux::PendingRequestDone() {
+  DCHECK(task_in_progress_);
+  task_in_progress_ = false;
+  ProcessNextPendingRequest();
+}
+
 void MTPDeviceDelegateImplLinux::ProcessNextPendingRequest() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(!task_in_progress_);
   if (pending_tasks_.empty())
     return;
 
   task_in_progress_ = true;
   const PendingTaskInfo& task_info = pending_tasks_.front();
   content::BrowserThread::PostTask(content::BrowserThread::UI,
                                    task_info.location,
                                    task_info.task);
   pending_tasks_.pop();
 }
 
 void MTPDeviceDelegateImplLinux::OnInitCompleted(bool succeeded) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   init_state_ = succeeded ? INITIALIZED : UNINITIALIZED;
-  task_in_progress_ = false;
-  ProcessNextPendingRequest();
+  PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidGetFileInfo(
     const GetFileInfoSuccessCallback& success_callback,
     const base::File::Info& file_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   success_callback.Run(file_info);
-  task_in_progress_ = false;
-  ProcessNextPendingRequest();
+  PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidGetFileInfoToReadDirectory(
     const std::string& root,
     const ReadDirectorySuccessCallback& success_callback,
     const ErrorCallback& error_callback,
     const base::File::Info& file_info) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(task_in_progress_);
   if (!file_info.is_directory) {
@@ skipping 44 matching lines @@
         snapshot_file_info, current_snapshot_request_info_->snapshot_file_path);
   }
   WriteDataIntoSnapshotFile(snapshot_file_info);
 }
 
 void MTPDeviceDelegateImplLinux::OnDidReadDirectory(
     const ReadDirectorySuccessCallback& success_callback,
     const fileapi::AsyncFileUtil::EntryList& file_list) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   success_callback.Run(file_list, false /*no more entries*/);
-  task_in_progress_ = false;
-  ProcessNextPendingRequest();
+  PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidWriteDataIntoSnapshotFile(
     const base::File::Info& file_info,
     const base::FilePath& snapshot_file_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(current_snapshot_request_info_.get());
-  DCHECK(task_in_progress_);
   current_snapshot_request_info_->success_callback.Run(
       file_info, snapshot_file_path);
-  task_in_progress_ = false;
   current_snapshot_request_info_.reset();
-  ProcessNextPendingRequest();
+  PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::OnWriteDataIntoSnapshotFileError(
     base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(current_snapshot_request_info_.get());
-  DCHECK(task_in_progress_);
   current_snapshot_request_info_->error_callback.Run(error);
-  task_in_progress_ = false;
   current_snapshot_request_info_.reset();
-  ProcessNextPendingRequest();
+  PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::OnDidReadBytes(
     const ReadBytesSuccessCallback& success_callback,
     const base::File::Info& file_info, int bytes_read) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-  DCHECK(task_in_progress_);
   success_callback.Run(file_info, bytes_read);
-  task_in_progress_ = false;
-  ProcessNextPendingRequest();
+  PendingRequestDone();
 }
 
 void MTPDeviceDelegateImplLinux::HandleDeviceFileError(
     const ErrorCallback& error_callback,
     base::File::Error error) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
-  DCHECK(task_in_progress_);
   error_callback.Run(error);
-  task_in_progress_ = false;
-  ProcessNextPendingRequest();
+  PendingRequestDone();
 }
 
 void CreateMTPDeviceAsyncDelegate(
     const std::string& device_location,
     const CreateMTPDeviceAsyncDelegateCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   callback.Run(new MTPDeviceDelegateImplLinux(device_location));
 }