[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,
+    scoped_refptr<net::IOBuffer> buffer,
     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;
   }
@@ skipping 103 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,
+    scoped_refptr<net::IOBuffer> buffer,
     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;
   }
 
@@ skipping 74 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