[fsp] Fix crash when reading files.

chrome/browser/chromeos/file_system_provider/fileapi/file_stream_reader.cc

 // Copyright 2014 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/file_system_provider/fileapi/file_stream_reader.h"
 
 #include "base/files/file.h"
+#include "base/memory/ref_counted.h"
 #include "chrome/browser/chromeos/file_system_provider/fileapi/provider_async_file_util.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
 #include "content/public/browser/browser_thread.h"
+#include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 namespace file_system_provider {
 namespace {
 
 // Dicards the callback from CloseFile().
 void EmptyStatusCallback(base::File::Error /* result */) {
@@ skipping 53 matching lines @@
     file_system->CloseFile(file_handle, base::Bind(&EmptyStatusCallback));
 }
 
 // Requests reading contents of a file. In case of either success or a failure
 // |callback| is executed. It can be called many times, until |has_next| is set
 // to false. This function guarantees that it will succeed only if the file has
 // not been changed while reading. Must be called on UI thread.
 void ReadFileOnUIThread(
     base::WeakPtr<ProvidedFileSystemInterface> file_system,
     int file_handle,
     net::IOBuffer* buffer,

[kinaba, 2014/05/30 04:42:10]

What about taking 
scoped_refptr<net::IOBuffer>
as the arugment at this point?

[mtomasz, 2014/06/02 00:47:52]

Done.

     int64 offset,
     int length,
     const ProvidedFileSystemInterface::ReadChunkReceivedCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // If the file system got unmounted, then abort the reading operation.
   if (!file_system.get()) {
     callback.Run(0, false /* has_next */, base::File::FILE_ERROR_ABORT);
     return;
   }
 
-  file_system->ReadFile(file_handle, buffer, offset, length, callback);
+  file_system->ReadFile(
+      file_handle, make_scoped_refptr(buffer), offset, length, callback);
 }
 
 // Forward the completion callback to IO thread.
 void OnReadChunkReceivedOnUIThread(
     const ProvidedFileSystemInterface::ReadChunkReceivedCallback&
         chunk_received_callback,
     int chunk_length,
     bool has_next,
     base::File::Error result) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
@@ skipping 91 matching lines @@
   pending_closure.Run();
 }
 
 int FileStreamReader::Read(net::IOBuffer* buffer,
                            int buffer_length,
                            const net::CompletionCallback& callback) {
   // Lazily initialize with the first call to Read().
   if (!file_handle_) {
     Initialize(base::Bind(&FileStreamReader::ReadAfterInitialized,
                           weak_ptr_factory_.GetWeakPtr(),
-                          buffer,
+                          make_scoped_refptr(buffer),
                           buffer_length,
                           callback),
                base::Bind(&Int64ToIntCompletionCallback, callback));
     return net::ERR_IO_PENDING;
   }
 
   ReadAfterInitialized(buffer, buffer_length, callback);
   return net::ERR_IO_PENDING;
 }
 
 int64 FileStreamReader::GetLength(
     const net::Int64CompletionCallback& callback) {
   // Lazily initialize with the first call to GetLength().
   if (!file_handle_) {
     Initialize(base::Bind(&FileStreamReader::GetLengthAfterInitialized,
                           weak_ptr_factory_.GetWeakPtr(),
                           callback),
                callback);
     return net::ERR_IO_PENDING;
   }
 
   GetLengthAfterInitialized(callback);
   return net::ERR_IO_PENDING;
 }
 
 void FileStreamReader::ReadAfterInitialized(
     net::IOBuffer* buffer,

[kinaba, 2014/05/30 04:42:10]

ditto.

[mtomasz, 2014/06/02 00:47:52]

Done.

     int buffer_length,
     const net::CompletionCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   // If the file system got unmounted, then abort the reading operation.
   if (!file_handle_) {
     callback.Run(net::ERR_ABORTED);
     return;
   }
 
   current_length_ = 0;
   BrowserThread::PostTask(
       BrowserThread::UI,
       FROM_HERE,
       base::Bind(&ReadFileOnUIThread,
                  file_system_,
                  file_handle_,
-                 buffer,
+                 make_scoped_refptr(buffer),
                  current_offset_,
                  buffer_length,
                  base::Bind(&OnReadChunkReceivedOnUIThread,
                             base::Bind(&FileStreamReader::OnReadChunkReceived,
                                        weak_ptr_factory_.GetWeakPtr(),
                                        callback))));
 }
 
 void FileStreamReader::GetLengthAfterInitialized(
     const net::Int64CompletionCallback& callback) {
@@ skipping 56 matching lines @@
     callback.Run(net::FileErrorToNetError(result));
     return;
   }
 
   DCHECK_EQ(result, base::File::FILE_OK);
   callback.Run(file_info.size);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos