Remove implicit conversions from scoped_refptr to T* in mojo/

mojo/embedder/simple_platform_shared_buffer_unittest.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 "mojo/embedder/simple_platform_shared_buffer.h"
 
 #include <limits>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
 namespace embedder {
 namespace {
 
 TEST(SimplePlatformSharedBufferTest, Basic) {
   const size_t kNumInts = 100;
   const size_t kNumBytes = kNumInts * sizeof(int);
   // A fudge so that we're not just writing zero bytes 75% of the time.
   const int kFudge = 1234567890;
 
   // Make some memory.
   scoped_refptr<SimplePlatformSharedBuffer> buffer(
       SimplePlatformSharedBuffer::Create(kNumBytes));
-  ASSERT_TRUE(buffer);
+  ASSERT_TRUE(buffer.get());
 
   // Map it all, scribble some stuff, and then unmap it.
   {
     EXPECT_TRUE(buffer->IsValidMap(0, kNumBytes));
     scoped_ptr<PlatformSharedBufferMapping> mapping(buffer->Map(0, kNumBytes));
     ASSERT_TRUE(mapping);
     ASSERT_TRUE(mapping->GetBase());
     int* stuff = static_cast<int*>(mapping->GetBase());
     for (size_t i = 0; i < kNumInts; i++)
       stuff[i] = static_cast<int>(i) + kFudge;
@@ skipping 55 matching lines @@
       }
     }
   }
 }
 
 // TODO(vtl): Bigger buffers.
 
 TEST(SimplePlatformSharedBufferTest, InvalidMappings) {
   scoped_refptr<SimplePlatformSharedBuffer> buffer(
       SimplePlatformSharedBuffer::Create(100));
-  ASSERT_TRUE(buffer);
+  ASSERT_TRUE(buffer.get());
 
   // Zero length not allowed.
   EXPECT_FALSE(buffer->Map(0, 0));
   EXPECT_FALSE(buffer->IsValidMap(0, 0));
 
   // Okay:
   EXPECT_TRUE(buffer->Map(0, 100));
   EXPECT_TRUE(buffer->IsValidMap(0, 100));
   // Offset + length too big.
   EXPECT_FALSE(buffer->Map(0, 101));
@@ skipping 12 matching lines @@
 }
 
 TEST(SimplePlatformSharedBufferTest, TooBig) {
   // If |size_t| is 32-bit, it's quite possible/likely that |Create()| succeeds
   // (since it only involves creating a 4 GB file).
   const size_t kMaxSizeT = std::numeric_limits<size_t>::max();
   scoped_refptr<SimplePlatformSharedBuffer> buffer(
       SimplePlatformSharedBuffer::Create(kMaxSizeT));
   // But, assuming |sizeof(size_t) == sizeof(void*)|, mapping all of it should
   // always fail.
-  if (buffer)
+  if (buffer.get())
     EXPECT_FALSE(buffer->Map(0, kMaxSizeT));
 }
 
 // Tests that separate mappings get distinct addresses.
 // Note: It's not inconceivable that the OS could ref-count identical mappings
 // and reuse the same address, in which case we'd have to be more careful about
 // using the address as the key for unmapping.
 TEST(SimplePlatformSharedBufferTest, MappingsDistinct) {
   scoped_refptr<SimplePlatformSharedBuffer> buffer(
       SimplePlatformSharedBuffer::Create(100));
@@ skipping 31 matching lines @@
 
   EXPECT_EQ('x', static_cast<char*>(mapping2->GetBase())[0]);
 
   static_cast<char*>(mapping2->GetBase())[1] = 'y';
   EXPECT_EQ('y', static_cast<char*>(mapping1->GetBase())[51]);
 }
 
 }  // namespace
 }  // namespace embedder
 }  // namespace mojo