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

webkit/browser/fileapi/local_file_stream_writer_unittest.cc

 // Copyright (c) 2012 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 "webkit/browser/fileapi/local_file_stream_writer.h"
 
 #include <string>
 
 #include "base/callback.h"
 #include "base/file_util.h"
@@ skipping 19 matching lines @@
 
  protected:
   base::FilePath Path(const std::string& name) {
     return temp_dir_.path().AppendASCII(name);
   }
 
   int WriteStringToWriter(LocalFileStreamWriter* writer,
                           const std::string& data) {
     scoped_refptr<net::StringIOBuffer> buffer(new net::StringIOBuffer(data));
     scoped_refptr<net::DrainableIOBuffer> drainable(
-        new net::DrainableIOBuffer(buffer, buffer->size()));
+        new net::DrainableIOBuffer(buffer.get(), buffer->size()));
 
     while (drainable->BytesRemaining() > 0) {
       net::TestCompletionCallback callback;
-      int result = writer->Write(drainable, drainable->BytesRemaining(),
-                                 callback.callback());
+      int result = writer->Write(
+          drainable.get(), drainable->BytesRemaining(), callback.callback());
       if (result == net::ERR_IO_PENDING)
         result = callback.WaitForResult();
       if (result <= 0)
         return result;
       drainable->DidConsume(result);
     }
     return net::OK;
   }
 
   std::string GetFileContent(const base::FilePath& path) {
@@ skipping 83 matching lines @@
   // Write operation is already completed.
   EXPECT_TRUE(file_util::PathExists(path));
   EXPECT_EQ("foo", GetFileContent(path));
 }
 
 TEST_F(LocalFileStreamWriterTest, CancelWrite) {
   base::FilePath path = CreateFileWithContent("file_a", "foobar");
   scoped_ptr<LocalFileStreamWriter> writer(new LocalFileStreamWriter(path, 0));
 
   scoped_refptr<net::StringIOBuffer> buffer(new net::StringIOBuffer("xxx"));
-  int result = writer->Write(buffer, buffer->size(), base::Bind(&NeverCalled));
+  int result =
+      writer->Write(buffer.get(), buffer->size(), base::Bind(&NeverCalled));
   ASSERT_EQ(net::ERR_IO_PENDING, result);
 
   net::TestCompletionCallback callback;
   writer->Cancel(callback.callback());
   int cancel_result = callback.WaitForResult();
   EXPECT_EQ(net::OK, cancel_result);
 }