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

webkit/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.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/common/gpu/webgraphicscontext3d_in_process_command_buffer_impl.h"
 
 #include <GLES2/gl2.h>
 #ifndef GL_GLEXT_PROTOTYPES
 #define GL_GLEXT_PROTOTYPES 1
 #endif
@@ skipping 339 matching lines @@
   scoped_ptr<GpuMemoryBuffer> buffer =
       g_gpu_memory_buffer_creator(width, height);
 
   if (buffer.get() == NULL)
     return buffer.Pass();
 
   scoped_refptr<gfx::GLImage> gl_image =
       gfx::GLImage::CreateGLImageForGpuMemoryBuffer(buffer->GetNativeBuffer(),
                                                     gfx::Size(width, height));
   *image_id = ++next_id_;  // Valid image_ids start from 1.
-  image_manager_->AddImage(gl_image, *image_id);
+  image_manager_->AddImage(gl_image.get(), *image_id);
   return buffer.Pass();
 }
 
 void ImageFactoryInProcess::DeleteGpuMemoryBuffer(unsigned int image_id) {
   // We're taking the lock here because we're accessing the ContextGroup's
   // shared ImageManager.
   AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
                                       g_all_shared_contexts.Get());
   image_manager_->RemoveImage(image_id);
 }
@@ skipping 235 matching lines @@
                                           decoder_.get(),
                                           decoder_.get()));
 
     decoder_->set_engine(gpu_scheduler_.get());
 
     if (is_offscreen)
       surface_ = gfx::GLSurface::CreateOffscreenGLSurface(false, size);
     else
       surface_ = gfx::GLSurface::CreateViewGLSurface(false, window);
 
-    if (!surface_) {
+    if (!surface_.get()) {
       LOG(ERROR) << "Could not create GLSurface.";
       Destroy();
       return false;
     }
 
     if (g_use_virtualized_gl_context) {
       context_ = share_group->GetSharedContext();
-      if (!context_) {
-        context_ = gfx::GLContext::CreateGLContext(share_group.get(),
-                                                   surface_.get(),
-                                                   gpu_preference);
-        share_group->SetSharedContext(context_);
+      if (!context_.get()) {
+        context_ = gfx::GLContext::CreateGLContext(
+            share_group.get(), surface_.get(), gpu_preference);
+        share_group->SetSharedContext(context_.get());
       }
 
-      context_ = new ::gpu::GLContextVirtual(share_group.get(),
-                                             context_,
-                                             decoder_->AsWeakPtr());
-      if (context_->Initialize(surface_, gpu_preference)) {
+      context_ = new ::gpu::GLContextVirtual(
+          share_group.get(), context_.get(), decoder_->AsWeakPtr());
+      if (context_->Initialize(surface_.get(), gpu_preference)) {
         VLOG(1) << "Created virtual GL context.";
       } else {
         context_ = NULL;
       }
     } else {
       context_ = gfx::GLContext::CreateGLContext(share_group.get(),
                                                  surface_.get(),
                                                  gpu_preference);
     }
 
-    if (!context_) {
+    if (!context_.get()) {
       LOG(ERROR) << "Could not create GLContext.";
       Destroy();
       return false;
     }
 
-    if (!context_->MakeCurrent(surface_)) {
+    if (!context_->MakeCurrent(surface_.get())) {
       LOG(ERROR) << "Could not make context current.";
       Destroy();
       return false;
     }
 
     ::gpu::gles2::DisallowedFeatures disallowed_features;
     disallowed_features.swap_buffer_complete_callback = true;
     disallowed_features.gpu_memory_manager = true;
     if (!decoder_->Initialize(surface_,
                               context_,
@@ skipping 47 matching lines @@
     image_factory_ = new ImageFactoryInProcess(GetImageManager());
   }
 
   // Create the object exposing the OpenGL API.
   gles2_implementation_.reset(new GLES2Implementation(
       gles2_helper_.get(),
       context_group ? context_group->GetImplementation()->share_group() : NULL,
       transfer_buffer_.get(),
       true,
       false,
-      image_factory_));
+      image_factory_.get()));
 
   if (!gles2_implementation_->Initialize(
       kStartTransferBufferSize,
       kMinTransferBufferSize,
       kMaxTransferBufferSize)) {
     return false;
   }
 
   if (share_resources_) {
     AutoLockAndDecoderDetachThread lock(g_decoder_lock.Get(),
@@ skipping 1274 matching lines @@
 DELEGATE_TO_GL_1(waitAsyncTexImage2DCHROMIUM, WaitAsyncTexImage2DCHROMIUM,
     WGC3Denum)
 
 void WebGraphicsContext3DInProcessCommandBufferImpl::SetGpuMemoryBufferCreator(
     GpuMemoryBufferCreator* creator) {
   g_gpu_memory_buffer_creator = creator;
 }
 
 }  // namespace gpu
 }  // namespace webkit