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

cc/resources/resource_provider_unittest.cc

 // Copyright 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 "cc/resources/resource_provider.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ skipping 199 matching lines @@
                              WGC3Dint xoffset,
                              WGC3Dint yoffset,
                              WGC3Dsizei width,
                              WGC3Dsizei height,
                              WGC3Denum format,
                              WGC3Denum type,
                              const void* pixels) OVERRIDE {
     ASSERT_TRUE(current_texture_);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_FALSE(level);
-    ASSERT_TRUE(textures_[current_texture_]);
+    ASSERT_TRUE(textures_[current_texture_].get());
     ASSERT_EQ(textures_[current_texture_]->format, format);
     ASSERT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
     ASSERT_TRUE(pixels);
     SetPixels(xoffset, yoffset, width, height, pixels);
   }
 
   virtual void texParameteri(WGC3Denum target, WGC3Denum param, WGC3Dint value)
       OVERRIDE {
     ASSERT_TRUE(current_texture_);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     scoped_refptr<Texture> texture = textures_[current_texture_];
-    ASSERT_TRUE(texture);
+    ASSERT_TRUE(texture.get());
     if (param != GL_TEXTURE_MIN_FILTER)
       return;
     texture->filter = value;
   }
 
   virtual void genMailboxCHROMIUM(WGC3Dbyte* mailbox) OVERRIDE {
     return shared_data_->GenMailbox(mailbox);
   }
 
   virtual void produceTextureCHROMIUM(WGC3Denum target,
@@ skipping 14 matching lines @@
                                       const WGC3Dbyte* mailbox) OVERRIDE {
     ASSERT_TRUE(current_texture_);
     ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     textures_[current_texture_] = shared_data_->ConsumeTexture(
         mailbox, last_waited_sync_point_);
   }
 
   void GetPixels(gfx::Size size, WGC3Denum format, uint8_t* pixels) {
     ASSERT_TRUE(current_texture_);
     scoped_refptr<Texture> texture = textures_[current_texture_];
-    ASSERT_TRUE(texture);
+    ASSERT_TRUE(texture.get());
     ASSERT_EQ(texture->size, size);
     ASSERT_EQ(texture->format, format);
     memcpy(pixels, texture->data.get(), TextureSize(size, format));
   }
 
   WGC3Denum GetTextureFilter() {
     DCHECK(current_texture_);
     scoped_refptr<Texture> texture = textures_[current_texture_];
-    DCHECK(texture);
+    DCHECK(texture.get());
     return texture->filter;
   }
 
   int texture_count() { return textures_.size(); }
 
  protected:
   ResourceProviderContext(const Attributes& attrs,
                           ContextSharedData* shared_data)
       : TestWebGraphicsContext3D(attrs),
         shared_data_(shared_data),
         current_texture_(0),
         last_waited_sync_point_(0) {}
 
  private:
   void AllocateTexture(gfx::Size size, WGC3Denum format) {
     ASSERT_TRUE(current_texture_);
     scoped_refptr<Texture> texture = textures_[current_texture_];
-    ASSERT_TRUE(texture);
+    ASSERT_TRUE(texture.get());
     texture->Reallocate(size, format);
   }
 
   void SetPixels(int xoffset,
                  int yoffset,
                  int width,
                  int height,
                  const void* pixels) {
     ASSERT_TRUE(current_texture_);
     scoped_refptr<Texture> texture = textures_[current_texture_];
-    ASSERT_TRUE(texture);
+    ASSERT_TRUE(texture.get());
     ASSERT_TRUE(texture->data.get());
     ASSERT_TRUE(xoffset >= 0 && xoffset + width <= texture->size.width());
     ASSERT_TRUE(yoffset >= 0 && yoffset + height <= texture->size.height());
     ASSERT_TRUE(pixels);
     size_t in_pitch = TextureSize(gfx::Size(width, 1), texture->format);
     size_t out_pitch =
         TextureSize(gfx::Size(texture->size.width(), 1), texture->format);
     uint8_t* dest = texture->data.get() + yoffset * out_pitch +
                     TextureSize(gfx::Size(xoffset, 1), texture->format);
     const uint8_t* src = static_cast<const uint8_t*>(pixels);
@@ skipping 1238 matching lines @@
       .RetiresOnSaturation();
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceProviderTests,
     ResourceProviderTest,
     ::testing::Values(ResourceProvider::GLTexture, ResourceProvider::Bitmap));
 
 }  // namespace
 }  // namespace cc