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

gpu/command_buffer/service/framebuffer_manager.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 "gpu/command_buffer/service/framebuffer_manager.h"
 #include "base/logging.h"
 #include "base/stringprintf.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/service/renderbuffer_manager.h"
 #include "gpu/command_buffer/service/texture_manager.h"
@@ skipping 49 matching lines @@
   }
 
   virtual bool cleared() const OVERRIDE {
     return renderbuffer_->cleared();
   }
 
   virtual void SetCleared(
       RenderbufferManager* renderbuffer_manager,
       TextureManager* /* texture_manager */,
       bool cleared) OVERRIDE {
-    renderbuffer_manager->SetCleared(renderbuffer_, cleared);
+    renderbuffer_manager->SetCleared(renderbuffer_.get(), cleared);
   }
 
   virtual bool IsTexture(
       TextureRef* /* texture */) const OVERRIDE {
     return false;
   }
 
   virtual bool IsRenderbuffer(
        Renderbuffer* renderbuffer) const OVERRIDE {
-     return renderbuffer_ == renderbuffer;
+    return renderbuffer_.get() == renderbuffer;
   }
 
   virtual bool CanRenderTo() const OVERRIDE {
     return true;
   }
 
   virtual void DetachFromFramebuffer() const OVERRIDE {
     // Nothing to do for renderbuffers.
   }
 
@@ skipping 67 matching lines @@
   }
 
   virtual bool cleared() const OVERRIDE {
     return texture_ref_->texture()->IsLevelCleared(target_, level_);
   }
 
   virtual void SetCleared(
       RenderbufferManager* /* renderbuffer_manager */,
       TextureManager* texture_manager,
       bool cleared) OVERRIDE {
-    texture_manager->SetLevelCleared(texture_ref_, target_, level_, cleared);
+    texture_manager->SetLevelCleared(
+        texture_ref_.get(), target_, level_, cleared);
   }
 
   virtual bool IsTexture(TextureRef* texture) const OVERRIDE {
     return texture == texture_ref_.get();
   }
 
   virtual bool IsRenderbuffer(
        Renderbuffer* /* renderbuffer */)
           const OVERRIDE {
     return false;
@@ skipping 21 matching lines @@
     }
     uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
         attachment_type, max_color_attachments);
     uint32 have = GLES2Util::GetChannelsForFormat(internal_format);
     return (need & have) != 0;
   }
 
   virtual void AddToSignature(
       TextureManager* texture_manager, std::string* signature) const OVERRIDE {
     DCHECK(signature);
-    texture_manager->AddToSignature(texture_ref_, target_, level_, signature);
+    texture_manager->AddToSignature(
+        texture_ref_.get(), target_, level_, signature);
   }
 
  protected:
   virtual ~TextureAttachment() {}
 
  private:
   scoped_refptr<TextureRef> texture_ref_;
   GLenum target_;
   GLint level_;
 
@@ skipping 77 matching lines @@
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 bool Framebuffer::HasUnclearedAttachment(
     GLenum attachment) const {
   AttachmentMap::const_iterator it =
       attachments_.find(attachment);
   if (it != attachments_.end()) {
-    const Attachment* attachment = it->second;
+    const Attachment* attachment = it->second.get();
     return !attachment->cleared();
   }
   return false;
 }
 
 void Framebuffer::MarkAttachmentAsCleared(
       RenderbufferManager* renderbuffer_manager,
       TextureManager* texture_manager,
       GLenum attachment,
       bool cleared) {
   AttachmentMap::iterator it = attachments_.find(attachment);
   if (it != attachments_.end()) {
-    Attachment* a = it->second;
+    Attachment* a = it->second.get();
     if (a->cleared() != cleared) {
       a->SetCleared(renderbuffer_manager,
                     texture_manager,
                     cleared);
     }
   }
 }
 
 void Framebuffer::MarkAttachmentsAsCleared(
       RenderbufferManager* renderbuffer_manager,
       TextureManager* texture_manager,
       bool cleared) {
   for (AttachmentMap::iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
-    Attachment* attachment = it->second;
+    Attachment* attachment = it->second.get();
     if (attachment->cleared() != cleared) {
       attachment->SetCleared(renderbuffer_manager, texture_manager, cleared);
     }
   }
 }
 
 bool Framebuffer::HasDepthAttachment() const {
   return attachments_.find(GL_DEPTH_STENCIL_ATTACHMENT) != attachments_.end() ||
          attachments_.find(GL_DEPTH_ATTACHMENT) != attachments_.end();
 }
 
 bool Framebuffer::HasStencilAttachment() const {
   return attachments_.find(GL_DEPTH_STENCIL_ATTACHMENT) != attachments_.end() ||
          attachments_.find(GL_STENCIL_ATTACHMENT) != attachments_.end();
 }
 
 GLenum Framebuffer::GetColorAttachmentFormat() const {
   AttachmentMap::const_iterator it = attachments_.find(GL_COLOR_ATTACHMENT0);
   if (it == attachments_.end()) {
     return 0;
   }
-  const Attachment* attachment = it->second;
+  const Attachment* attachment = it->second.get();
   return attachment->internal_format();
 }
 
 GLenum Framebuffer::IsPossiblyComplete() const {
   if (attachments_.empty()) {
     return GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
   }
 
   GLsizei width = -1;
   GLsizei height = -1;
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
     GLenum attachment_type = it->first;
-    Attachment* attachment = it->second;
-    if (!attachment->ValidForAttachmentType(
-            attachment_type, manager_->max_color_attachments_)) {
+    Attachment* attachment = it->second.get();
+    if (!attachment->ValidForAttachmentType(attachment_type,
+                                            manager_->max_color_attachments_)) {
       return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
     }
     if (width < 0) {
       width = attachment->width();
       height = attachment->height();
       if (width == 0 || height == 0) {
         return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
       }
     } else {
       if (attachment->width() != width || attachment->height() != height) {
@@ skipping 12 matching lines @@
 }
 
 GLenum Framebuffer::GetStatus(
     TextureManager* texture_manager, GLenum target) const {
   // Check if we have this combo already.
   std::string signature;
   if (allow_framebuffer_combo_complete_map_) {
     signature = base::StringPrintf("|FBO|target=%04x", target);
     for (AttachmentMap::const_iterator it = attachments_.begin();
          it != attachments_.end(); ++it) {
-      Attachment* attachment = it->second;
-      signature += base::StringPrintf(
-          "|Attachment|attachmentpoint=%04x", it->first);
+      Attachment* attachment = it->second.get();
+      signature +=
+          base::StringPrintf("|Attachment|attachmentpoint=%04x", it->first);
       attachment->AddToSignature(texture_manager, &signature);
     }
 
     if (!framebuffer_combo_complete_map_) {
       framebuffer_combo_complete_map_ = new FramebufferComboCompleteMap();
     }
 
     FramebufferComboCompleteMap::const_iterator it =
         framebuffer_combo_complete_map_->find(signature);
     if (it != framebuffer_combo_complete_map_->end()) {
       return GL_FRAMEBUFFER_COMPLETE;
     }
   }
 
   GLenum result = glCheckFramebufferStatusEXT(target);
 
   // Insert the new result into the combo map.
   if (allow_framebuffer_combo_complete_map_ &&
       result == GL_FRAMEBUFFER_COMPLETE) {
     framebuffer_combo_complete_map_->insert(std::make_pair(signature, true));
   }
 
   return result;
 }
 
 bool Framebuffer::IsCleared() const {
   // are all the attachments cleaared?
   for (AttachmentMap::const_iterator it = attachments_.begin();
        it != attachments_.end(); ++it) {
-    Attachment* attachment = it->second;
+    Attachment* attachment = it->second.get();
     if (!attachment->cleared()) {
       return false;
     }
   }
   return true;
 }
 
 GLenum Framebuffer::GetDrawBuffer(GLenum draw_buffer) const {
   GLsizei index = static_cast<GLsizei>(
       draw_buffer - GL_DRAW_BUFFER0_ARB);
   CHECK(index >= 0 &&
         index < static_cast<GLsizei>(manager_->max_draw_buffers_));
   return draw_buffers_[index];
 }
 
 void Framebuffer::SetDrawBuffers(GLsizei n, const GLenum* bufs) {
   DCHECK(n <= static_cast<GLsizei>(manager_->max_draw_buffers_));
   for (GLsizei i = 0; i < n; ++i)
     draw_buffers_[i] = bufs[i];
 }
 
 void Framebuffer::UnbindRenderbuffer(
     GLenum target, Renderbuffer* renderbuffer) {
   bool done;
   do {
     done = true;
     for (AttachmentMap::const_iterator it = attachments_.begin();
          it != attachments_.end(); ++it) {
-      Attachment* attachment = it->second;
+      Attachment* attachment = it->second.get();
       if (attachment->IsRenderbuffer(renderbuffer)) {
         // TODO(gman): manually detach renderbuffer.
         // glFramebufferRenderbufferEXT(target, it->first, GL_RENDERBUFFER, 0);
         AttachRenderbuffer(it->first, NULL);
         done = false;
         break;
       }
     }
   } while (!done);
 }
 
 void Framebuffer::UnbindTexture(
     GLenum target, TextureRef* texture_ref) {
   bool done;
   do {
     done = true;
     for (AttachmentMap::const_iterator it = attachments_.begin();
          it != attachments_.end(); ++it) {
-      Attachment* attachment = it->second;
+      Attachment* attachment = it->second.get();
       if (attachment->IsTexture(texture_ref)) {
         // TODO(gman): manually detach texture.
         // glFramebufferTexture2DEXT(target, it->first, GL_TEXTURE_2D, 0, 0);
         AttachTexture(it->first, NULL, GL_TEXTURE_2D, 0);
         done = false;
         break;
       }
     }
   } while (!done);
 }
@@ skipping 40 matching lines @@
     attachments_.erase(attachment);
   }
   framebuffer_complete_state_count_id_ = 0;
 }
 
 const Framebuffer::Attachment*
     Framebuffer::GetAttachment(
         GLenum attachment) const {
   AttachmentMap::const_iterator it = attachments_.find(attachment);
   if (it != attachments_.end()) {
-    return it->second;
+    return it->second.get();
   }
   return NULL;
 }
 
 bool FramebufferManager::GetClientId(
     GLuint service_id, GLuint* client_id) const {
   // This doesn't need to be fast. It's only used during slow queries.
   for (FramebufferMap::const_iterator it = framebuffers_.begin();
        it != framebuffers_.end(); ++it) {
     if (it->second->service_id() == service_id) {
@@ skipping 25 matching lines @@
     Framebuffer* framebuffer) {
   DCHECK(framebuffer);
   return framebuffer->framebuffer_complete_state_count_id() ==
       framebuffer_state_change_count_;
 }
 
 }  // namespace gles2
 }  // namespace gpu