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

content/browser/renderer_host/image_transport_factory.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 "content/browser/renderer_host/image_transport_factory.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 624 matching lines @@
     PerCompositorData* data = per_compositor_data_[compositor];
     if (!data)
       data = CreatePerCompositorData(compositor);
     WebGraphicsContext3DCommandBufferImpl* context =
         CreateContextCommon(data->swap_client->AsWeakPtr(),
                             data->surface_id);
     BrowserCompositorOutputSurface* surface =
         new BrowserCompositorOutputSurface(
             context,
             per_compositor_data_[compositor]->surface_id,
-            output_surface_proxy_,
+            output_surface_proxy_.get(),
             base::MessageLoopProxy::current(),
             compositor->AsWeakPtr());
     if (data->reflector.get()) {
       data->reflector->CreateSharedTexture();
       data->reflector->AttachToOutputSurface(surface);
     }
     return surface;
   }
 
   virtual scoped_refptr<ui::Reflector> CreateReflector(
       ui::Compositor* source,
       ui::Layer* target) OVERRIDE {
     PerCompositorData* data = per_compositor_data_[source];
     DCHECK(data);
 
     if (data->reflector.get())
       RemoveObserver(data->reflector.get());
 
     data->reflector = new ReflectorImpl(
-        source, target, output_surface_proxy_,
-        data->surface_id);
+        source, target, output_surface_proxy_.get(), data->surface_id);
     AddObserver(data->reflector.get());
     return data->reflector;
   }
 
   virtual void RemoveReflector(
       scoped_refptr<ui::Reflector> reflector) OVERRIDE {
     ReflectorImpl* reflector_impl =
         static_cast<ReflectorImpl*>(reflector.get());
     PerCompositorData* data =
         per_compositor_data_[reflector_impl->mirrored_compositor()];
@@ skipping 32 matching lines @@
         shared_contexts_main_thread_->Context3d()->GetChannelID();
     return handle;
   }
 
   virtual void DestroySharedSurfaceHandle(
       gfx::GLSurfaceHandle surface) OVERRIDE {
   }
 
   virtual scoped_refptr<ui::Texture> CreateTransportClient(
       float device_scale_factor) OVERRIDE {
-    if (!shared_contexts_main_thread_)
-        return NULL;
+    if (!shared_contexts_main_thread_.get())
+      return NULL;
     scoped_refptr<ImageTransportClientTexture> image(
         new ImageTransportClientTexture(
             shared_contexts_main_thread_->Context3d(),
             device_scale_factor));
     return image;
   }
 
   virtual scoped_refptr<ui::Texture> CreateOwnedTexture(
       const gfx::Size& size,
       float device_scale_factor,
       unsigned int texture_id) OVERRIDE {
-    if (!shared_contexts_main_thread_)
-        return NULL;
+    if (!shared_contexts_main_thread_.get())
+      return NULL;
     scoped_refptr<OwnedTexture> image(new OwnedTexture(
         shared_contexts_main_thread_->Context3d(),
         size,
         device_scale_factor,
         texture_id));
     return image;
   }
 
   virtual GLHelper* GetGLHelper() OVERRIDE {
     if (!gl_helper_) {
       CreateSharedContextLazy();
       WebGraphicsContext3DCommandBufferImpl* context_for_main_thread =
           shared_contexts_main_thread_->Context3d();
       gl_helper_.reset(new GLHelper(context_for_main_thread));
     }
     return gl_helper_.get();
   }
 
   virtual uint32 InsertSyncPoint() OVERRIDE {
-    if (!shared_contexts_main_thread_)
+    if (!shared_contexts_main_thread_.get())
       return 0;
     return shared_contexts_main_thread_->Context3d()->insertSyncPoint();
   }
 
   virtual void WaitSyncPoint(uint32 sync_point) OVERRIDE {
-    if (!shared_contexts_main_thread_)
+    if (!shared_contexts_main_thread_.get())
       return;
     shared_contexts_main_thread_->Context3d()->waitSyncPoint(sync_point);
   }
 
   virtual void AddObserver(ImageTransportFactoryObserver* observer) OVERRIDE {
     observer_list_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(
       ImageTransportFactoryObserver* observer) OVERRIDE {
@@ skipping 109 matching lines @@
           base::Bind(&GpuProcessTransportFactory::OnLostMainThreadSharedContext,
                      factory_->callback_factory_.GetWeakPtr()));
     }
 
    private:
     GpuProcessTransportFactory* factory_;
   };
 
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForMainThread() OVERRIDE {
-    if (!shared_contexts_main_thread_ ||
+    if (!shared_contexts_main_thread_.get() ||
         shared_contexts_main_thread_->DestroyedOnMainThread()) {
       shared_contexts_main_thread_ = MainThreadContextProvider::Create(this);
-      if (shared_contexts_main_thread_ &&
+      if (shared_contexts_main_thread_.get() &&
           !shared_contexts_main_thread_->BindToCurrentThread())
         shared_contexts_main_thread_ = NULL;
     }
     return shared_contexts_main_thread_;
   }
 
   class CompositorThreadContextProvider : public ContextProviderCommandBuffer {
    public:
     static scoped_refptr<CompositorThreadContextProvider> Create(
         GpuProcessTransportFactory* factory) {
@@ skipping 13 matching lines @@
         CreateOffscreenContext3d() OVERRIDE {
       return make_scoped_ptr(factory_->CreateOffscreenContext());
     }
 
    private:
     GpuProcessTransportFactory* factory_;
   };
 
   virtual scoped_refptr<cc::ContextProvider>
       OffscreenContextProviderForCompositorThread() OVERRIDE {
-    if (!shared_contexts_compositor_thread_ ||
+    if (!shared_contexts_compositor_thread_.get() ||
         shared_contexts_compositor_thread_->DestroyedOnMainThread()) {
       shared_contexts_compositor_thread_ =
           CompositorThreadContextProvider::Create(this);
     }
     return shared_contexts_compositor_thread_;
   }
 
   void CreateSharedContextLazy() {
     scoped_refptr<cc::ContextProvider> provider =
         OffscreenContextProviderForMainThread();
-    if (!provider) {
+    if (!provider.get()) {
       // If we can't recreate contexts, we won't be able to show the UI.
       // Better crash at this point.
       FatalGPUError("Failed to initialize UI shared context.");
     }
   }
 
   void OnLostMainThreadSharedContext() {
     LOG(ERROR) << "Lost UI shared context.";
     // Keep old resources around while we call the observers, but ensure that
     // new resources are created if needed.
@@ skipping 100 matching lines @@
   delete g_factory;
   g_factory = NULL;
 }
 
 // static
 ImageTransportFactory* ImageTransportFactory::GetInstance() {
   return g_factory;
 }
 
 }  // namespace content