Update CrOS to use scoped_refptr<T>::get() rather than implicit "operator T*"

chrome/browser/chromeos/drive/drive_file_stream_reader.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/chromeos/drive/drive_file_stream_reader.h"
 
 #include <algorithm>
 #include <cstring>
 
 #include "base/callback_helpers.h"
@@ skipping 125 matching lines @@
 NetworkReaderProxy::~NetworkReaderProxy() {
   if (!job_canceller_.is_null()) {
     job_canceller_.Run();
   }
 }
 
 int NetworkReaderProxy::Read(net::IOBuffer* buffer, int buffer_length,
                              const net::CompletionCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Check if there is no pending Read operation.
-  DCHECK(!buffer_);
+  DCHECK(!buffer_.get());
   DCHECK_EQ(buffer_length_, 0);
   DCHECK(callback_.is_null());
   // Validate the arguments.
   DCHECK(buffer);
   DCHECK_GT(buffer_length, 0);
   DCHECK(!callback.is_null());
 
   if (error_code_ != net::OK) {
     // An error is already found. Return it immediately.
     return error_code_;
@@ skipping 33 matching lines @@
     return;
   }
 
   if (remaining_offset_ > 0) {
     // Erase unnecessary leading bytes.
     data->erase(0, static_cast<size_t>(remaining_offset_));
     remaining_offset_ = 0;
   }
 
   pending_data_.push_back(data.release());
-  if (!buffer_) {
+  if (!buffer_.get()) {
     // No pending Read operation.
     return;
   }
 
   int result = ReadInternal(&pending_data_, buffer_.get(), buffer_length_);
   remaining_content_length_ -= result;
   DCHECK_GE(remaining_content_length_, 0);
 
   buffer_ = NULL;
   buffer_length_ = 0;
@@ skipping 162 matching lines @@
         new internal::NetworkReaderProxy(
             byte_range.first_byte_position(), range_length,
             base::Bind(&google_apis::RunTaskOnUIThread,
                        ui_cancel_download_closure)));
     callback.Run(net::OK, entry.Pass());
     return;
   }
 
   // Otherwise, open the stream for file.
   scoped_ptr<util::LocalFileReader> file_reader(
-      new util::LocalFileReader(file_task_runner_));
+      new util::LocalFileReader(file_task_runner_.get()));
   util::LocalFileReader* file_reader_ptr = file_reader.get();
   file_reader_ptr->Open(
       local_cache_file_path,
       byte_range.first_byte_position(),
       base::Bind(
           &DriveFileStreamReader::InitializeAfterLocalFileOpen,
           weak_ptr_factory_.GetWeakPtr(),
           range_length,
           callback,
           base::Passed(&entry),
@@ skipping 43 matching lines @@
     // Note: due to the same reason, LocalReaderProxy::OnCompleted may
     // or may not be called. This is timing issue, and it is difficult to avoid
     // unfortunately.
     if (error != FILE_ERROR_OK) {
       callback.Run(FileErrorToNetError(error), scoped_ptr<ResourceEntry>());
     }
   }
 }
 
 }  // namespace drive