Remove implicit conversions from scoped_refptr to T* in components/nacl/

components/nacl/browser/pnacl_translation_cache_unittest.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 "components/nacl/browser/pnacl_translation_cache.h"
 
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
@@ skipping 50 matching lines @@
     ASSERT_EQ(net::OK, rv);
   ASSERT_EQ(net::OK, init_cb.GetResult(rv));
   ASSERT_EQ(0, cache_->Size());
 }
 
 void PnaclTranslationCacheTest::StoreNexe(const std::string& key,
                                           const std::string& nexe) {
   net::TestCompletionCallback store_cb;
   scoped_refptr<net::DrainableIOBuffer> nexe_buf(
       new net::DrainableIOBuffer(new net::StringIOBuffer(nexe), nexe.size()));
-  cache_->StoreNexe(key, nexe_buf, store_cb.callback());
+  cache_->StoreNexe(key, nexe_buf.get(), store_cb.callback());
   // Using ERR_IO_PENDING here causes the callback to wait for the result
   // which should be harmless even if it returns OK immediately. This is because
   // we don't plumb the intermediate writing stages all the way out.
   EXPECT_EQ(net::OK, store_cb.GetResult(net::ERR_IO_PENDING));
 }
 
 // Inspired by net::TestCompletionCallback. Instantiate a TestNexeCallback and
 // pass the GetNexeCallback returned by the callback() method to GetNexe.
 // Then call GetResult, which will pump the message loop until it gets a result,
 // return the resulting IOBuffer and fill in the return value
@@ skipping 137 matching lines @@
   StoreNexe(test_key, large_buffer);
   EXPECT_EQ(1, cache_->Size());
 }
 
 TEST_F(PnaclTranslationCacheTest, InMemSizeLimit) {
   InitBackend(true);
   scoped_refptr<net::DrainableIOBuffer> large_buffer(new net::DrainableIOBuffer(
       new net::StringIOBuffer(std::string(kMaxMemCacheSize + 1, 'a')),
       kMaxMemCacheSize + 1));
   net::TestCompletionCallback store_cb;
-  cache_->StoreNexe(test_key, large_buffer, store_cb.callback());
+  cache_->StoreNexe(test_key, large_buffer.get(), store_cb.callback());
   EXPECT_EQ(net::ERR_FAILED, store_cb.GetResult(net::ERR_IO_PENDING));
   base::RunLoop().RunUntilIdle();  // Ensure the entry is closed.
   EXPECT_EQ(0, cache_->Size());
 }
 
 TEST_F(PnaclTranslationCacheTest, GetOneInMem) {
   InitBackend(true);
   StoreNexe(test_key, test_store_val);
   EXPECT_EQ(1, cache_->Size());
   EXPECT_EQ(0, GetNexe(test_key).compare(test_store_val));
@@ skipping 37 matching lines @@
   StoreNexe(test_key, test_store_val);
   TestNexeCallback load_cb;
   std::string nexe;
   cache_->GetNexe(test_key + "a", load_cb.callback());
   int rv;
   scoped_refptr<net::DrainableIOBuffer> buf(load_cb.GetResult(&rv));
   EXPECT_EQ(net::ERR_FAILED, rv);
 }
 
 }  // namespace pnacl