MTP Streaming: Optimize block reading

chrome/browser/media_galleries/linux/mtp_device_task_helper.cc

 // Copyright 2013 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_task_helper.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
@@ skipping 91 matching lines @@
                              base::File::FILE_ERROR_FAILED);
   }
 
   if (!read_file_worker_)
     read_file_worker_.reset(new MTPReadFileWorker(device_handle_));
   read_file_worker_->WriteDataIntoSnapshotFile(request_info,
                                                snapshot_file_info);
 }
 
 void MTPDeviceTaskHelper::ReadBytes(
-    const MTPDeviceAsyncDelegate::ReadBytesRequest& request) {
+    const std::string& device_file_relative_path,
+    net::IOBuffer* buf, int64 offset, int buf_len,
+    const ReadBytesSuccessCallback& success_callback,
+    const ErrorCallback& error_callback) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (device_handle_.empty()) {
-    return HandleDeviceError(request.error_callback,
-                             base::File::FILE_ERROR_FAILED);
+    return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
   }
 
   GetMediaTransferProtocolManager()->ReadFileChunkByPath(
       device_handle_,
-      request.device_file_relative_path,
-      base::checked_cast<uint32>(request.offset),
-      base::checked_cast<uint32>(request.buf_len),
+      device_file_relative_path,
+      base::checked_cast<uint32>(offset),
+      base::checked_cast<uint32>(buf_len),
       base::Bind(&MTPDeviceTaskHelper::OnDidReadBytes,
-                 weak_ptr_factory_.GetWeakPtr(), request));
+                 weak_ptr_factory_.GetWeakPtr(), make_scoped_refptr(buf),
+                 buf_len, success_callback, error_callback));
 }
 
 void MTPDeviceTaskHelper::CloseStorage() const {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (device_handle_.empty())
     return;
   GetMediaTransferProtocolManager()->CloseStorage(device_handle_,
                                                   base::Bind(&DoNothing));
 }
 
@@ skipping 53 matching lines @@
     entry.size = file_enum.Size();
     entry.last_modified_time = file_enum.LastModifiedTime();
     entries.push_back(entry);
   }
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(success_callback, entries));
 }
 
 void MTPDeviceTaskHelper::OnDidReadBytes(
-    const MTPDeviceAsyncDelegate::ReadBytesRequest& request,
+    net::IOBuffer* buf, int buf_len,
+    const ReadBytesSuccessCallback& success_callback,
+    const ErrorCallback& error_callback,
     const std::string& data,
     bool error) const {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   if (error) {
-    return HandleDeviceError(request.error_callback,
-                             base::File::FILE_ERROR_FAILED);
+    return HandleDeviceError(error_callback, base::File::FILE_ERROR_FAILED);
   }
 
-  CHECK_LE(base::checked_cast<int>(data.length()), request.buf_len);
-  std::copy(data.begin(), data.end(), request.buf->data());
+  CHECK_LE(base::checked_cast<int>(data.length()), buf_len);
+  std::copy(data.begin(), data.end(), buf->data());
 
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
-                                   base::Bind(request.success_callback,
-                                              data.length()));
+                                   base::Bind(success_callback, data.length()));
 }
 
 void MTPDeviceTaskHelper::HandleDeviceError(
     const ErrorCallback& error_callback,
     base::File::Error error) const {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   content::BrowserThread::PostTask(content::BrowserThread::IO,
                                    FROM_HERE,
                                    base::Bind(error_callback, error));
 }