Media Galleries: On Linux, write data to snapshots in chunks rather than at once.

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 <fcntl.h>
+#include <sys/stat.h>
+#include <sys/types.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/string_util.h"
 #include "base/synchronization/cancellation_flag.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"
@@ skipping 329 matching lines @@
   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,
-                 uint32 total_size,
+                 uint32 read_offset,
+                 uint32 bytes_to_read,
                  SequencedTaskRunner* task_runner,
                  WaitableEvent* task_completed_event,
                  WaitableEvent* shutdown_event)
       : device_handle_(handle),
         path_(path),
-        total_bytes_(total_size),
-        error_occurred_(false),
+        read_offset_(read_offset),
+        bytes_to_read_(bytes_to_read),
         media_task_runner_(task_runner),
         on_task_completed_event_(task_completed_event),
         on_shutdown_event_(shutdown_event) {
     DCHECK(on_task_completed_event_);
     DCHECK(on_shutdown_event_);
   }
 
   // This function is invoked on |media_task_runner_| to post the task on UI
   // thread. This blocks the |media_task_runner_| until the task is complete.
   void Run() {
     if (on_shutdown_event_->IsSignaled()) {
       // Process is in shutdown mode.
       // Do not post any task on |media_task_runner_|.
       return;
     }
 
-    while (!error_occurred_ && (data_.size() < total_bytes_) &&
-           !cancel_tasks_flag_.IsSet()) {
-      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                              Bind(&ReadFileWorker::DoWorkOnUIThread, this));
-      on_task_completed_event_->Wait();
-      if (on_shutdown_event_->IsSignaled())

[kmadhusu, 2012/11/29 18:08:17]

Instead of moving this logic from ReadFileWorker => MTPDeviceDelegateImplLinux,
have you considered passing |local_path| to ReadFileWorker and appending the
data contents to the snapshot file? By doing that, CreateSnapshotFile
implementation will be simpler and all the read file logic will be confined to
ReadFileWorker class.

[Lei Zhang, 2012/11/30 01:01:34]

Done.

-        cancel_tasks_flag_.Set();
-    }
+    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 from mtpd.
   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();
@@ skipping 10 matching lines @@
   }
 
   // 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()->ReadFileChunkByPath(
-        device_handle_, path_, data_.size(), BytesToRead(),
+        device_handle_, path_, read_offset_, bytes_to_read_,
         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 (cancel_tasks_flag_.IsSet())
       return;
 
-    error_occurred_ = error;
     if (!error) {
-      if ((BytesToRead() == data.size())) {
-        // 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_.append(data);
-      } else {
-        NOTREACHED();
-        error_occurred_ = true;
-      }
+      DCHECK_EQ(bytes_to_read_, data.size());
+      data_ = data;
     }
     on_task_completed_event_->Signal();
   }
 
-  uint32 BytesToRead() const {
-    // Read data in 1 MB chunks.
-    static const uint32 kReadChunkSize = 1024 * 1024;
-    return std::min(kReadChunkSize,
-                    total_bytes_ - static_cast<uint32>(data_.size()));
-  }
-
   // The device unique identifier to query the device.
   const std::string device_handle_;
 
   // The media device file path.
   const std::string path_;
 
+  const uint32 read_offset_;
+  const uint32 bytes_to_read_;
+
   // The data from mtpd.
   std::string data_;
 
-  // Number of bytes to read.
-  const uint32 total_bytes_;
-
-  // Whether an error occurred during file transfer.
-  bool error_occurred_;
-
   // 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_;
 
@@ skipping 374 matching lines @@
   if (!LazyInit())
     return base::PLATFORM_FILE_ERROR_FAILED;
 
   PlatformFileError error = GetFileInfo(device_file_path, file_info);
   if (error != base::PLATFORM_FILE_OK)
     return error;
 
   if (file_info->size <= 0 || file_info->size > kuint32max)
     return base::PLATFORM_FILE_ERROR_FAILED;
 
-  scoped_refptr<ReadFileWorker> worker(new ReadFileWorker(
-      device_handle_,
-      GetDeviceRelativePath(device_path_, device_file_path.value()),
-      file_info->size,
-      media_task_runner_, &on_task_completed_event_, &on_shutdown_event_));
-  worker->Run();
+  // Read data in 1 MB chunks.
+  static const uint32 kReadChunkSize = 1024 * 1024;
+  uint32 bytes_remaining = file_info->size;
+  int fd = open(local_path.value().c_str(), O_WRONLY);
+  if (fd < 0)
+    return base::PLATFORM_FILE_ERROR_FAILED;
+  file_util::ScopedFD fd_scoper(&fd);
 
-  const std::string& file_data = worker->data();
-  int data_size = static_cast<int>(file_data.length());
-  if (file_data.empty() ||
-      file_util::WriteFile(local_path, file_data.c_str(),
-                           data_size) != data_size) {
-    return base::PLATFORM_FILE_ERROR_FAILED;
+  while (bytes_remaining > 0) {
+    uint32 offset = file_info->size - bytes_remaining;
+    uint32 bytes_to_read = std::min(kReadChunkSize, bytes_remaining);
+
+    scoped_refptr<ReadFileWorker> worker(new ReadFileWorker(
+        device_handle_,
+        GetDeviceRelativePath(device_path_, device_file_path.value()),
+        offset, bytes_to_read,
+        media_task_runner_, &on_task_completed_event_, &on_shutdown_event_));
+    worker->Run();
+
+    const std::string& file_data = worker->data();
+    int data_size = static_cast<int>(file_data.length());
+    if (bytes_to_read != file_data.length() ||
+        file_util::WriteFileDescriptor(fd, file_data.c_str(), data_size) < 0) {
+      return base::PLATFORM_FILE_ERROR_FAILED;
+    }
+
+    bytes_remaining -= data_size;
   }
 
   // Modify the last modified time to null. This prevents the time stamp
   // verfication in LocalFileStreamReader.
   file_info->last_modified = base::Time();
-  return error;
+  return base::PLATFORM_FILE_OK;
 }
 
 SequencedTaskRunner* MTPDeviceDelegateImplLinux::GetMediaTaskRunner() {
   return media_task_runner_.get();
 }
 
 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
@@ skipping 40 matching lines @@
 }
 
 void MTPDeviceDelegateImplLinux::DeleteDelegateOnTaskRunner() {
   DCHECK(media_task_runner_->RunsTasksOnCurrentThread());
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           Bind(&CloseStorageOnUIThread, device_handle_));
   delete this;
 }
 
 }  // namespace chrome