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

chrome/browser/chromeos/drive/local_file_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/local_file_reader.h"
 
 #include <errno.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 99 matching lines @@
   base::PlatformFile platform_file_;
 
   DISALLOW_COPY_AND_ASSIGN(ScopedPlatformFile);
 };
 
 LocalFileReader::LocalFileReader(
     base::SequencedTaskRunner* sequenced_task_runner)
     : sequenced_task_runner_(sequenced_task_runner),
       platform_file_(base::kInvalidPlatformFileValue),
       weak_ptr_factory_(this) {
-  DCHECK(sequenced_task_runner_);
+  DCHECK(sequenced_task_runner_.get());
 }
 
 LocalFileReader::~LocalFileReader() {
   PostCloseIfNeeded(sequenced_task_runner_.get(), platform_file_);
 }
 
 void LocalFileReader::Open(const base::FilePath& file_path,
                            int64 offset,
                            const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK_EQ(base::kInvalidPlatformFileValue, platform_file_);
 
   ScopedPlatformFile* platform_file =
-      new ScopedPlatformFile(sequenced_task_runner_);
+      new ScopedPlatformFile(sequenced_task_runner_.get());
   base::PostTaskAndReplyWithResult(
-      sequenced_task_runner_,
+      sequenced_task_runner_.get(),
       FROM_HERE,
-      base::Bind(&OpenAndSeekOnBlockingPool,
-                 file_path, offset, platform_file->ptr()),
+      base::Bind(
+          &OpenAndSeekOnBlockingPool, file_path, offset, platform_file->ptr()),
       base::Bind(&LocalFileReader::OpenAfterBlockingPoolTask,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback, base::Owned(platform_file)));
+                 callback,
+                 base::Owned(platform_file)));
 }
 
 void LocalFileReader::Read(net::IOBuffer* in_buffer,
                            int buffer_length,
                            const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   DCHECK_NE(base::kInvalidPlatformFileValue, platform_file_);
 
   scoped_refptr<net::IOBuffer> buffer(in_buffer);
   base::PostTaskAndReplyWithResult(
-      sequenced_task_runner_,
+      sequenced_task_runner_.get(),
       FROM_HERE,
       base::Bind(&ReadOnBlockingPool, platform_file_, buffer, buffer_length),
       callback);
 }
 
 void LocalFileReader::OpenAfterBlockingPoolTask(
     const net::CompletionCallback& callback,
     ScopedPlatformFile* platform_file,
     int open_result) {
   DCHECK(!callback.is_null());
   DCHECK(platform_file);
   DCHECK_EQ(base::kInvalidPlatformFileValue, platform_file_);
 
   if (open_result == net::OK) {
     DCHECK_NE(base::kInvalidPlatformFileValue, *platform_file->ptr());
     platform_file_ = platform_file->release();
   }
 
   callback.Run(open_result);
 }
 
 }  // namespace util
 }  // namespace drive