gpu/command_buffer/service/framebuffer_manager.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "gpu/command_buffer/service/framebuffer_manager.h"
   6 #include "base/logging.h"
   7 #include "base/strings/stringprintf.h"
   8 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
   9 #include "gpu/command_buffer/service/renderbuffer_manager.h"
  10 #include "gpu/command_buffer/service/texture_manager.h"
  11 #include "ui/gl/gl_bindings.h"
  12
  13 namespace gpu {
  14 namespace gles2 {
  15
  16 DecoderFramebufferState::DecoderFramebufferState()
  17     : clear_state_dirty(false),
  18       bound_read_framebuffer(NULL),
  19       bound_draw_framebuffer(NULL) {
  20 }
  21
  22 DecoderFramebufferState::~DecoderFramebufferState() {
  23 }
  24
  25 Framebuffer::FramebufferComboCompleteMap*
  26     Framebuffer::framebuffer_combo_complete_map_;
  27
  28 // Framebuffer completeness is not cacheable on OS X because of dynamic
  29 // graphics switching.
  30 // http://crbug.com/180876
  31 #if defined(OS_MACOSX)
  32 bool Framebuffer::allow_framebuffer_combo_complete_map_ = false;
  33 #else
  34 bool Framebuffer::allow_framebuffer_combo_complete_map_ = true;
  35 #endif
  36
  37 void Framebuffer::ClearFramebufferCompleteComboMap() {
  38   if (framebuffer_combo_complete_map_) {
  39     framebuffer_combo_complete_map_->clear();
  40   }
  41 }
  42
  43 class RenderbufferAttachment
  44     : public Framebuffer::Attachment {
  45  public:
  46   explicit RenderbufferAttachment(
  47       Renderbuffer* renderbuffer)
  48       : renderbuffer_(renderbuffer) {
  49   }
  50
  51   virtual GLsizei width() const OVERRIDE {
  52     return renderbuffer_->width();
  53   }
  54
  55   virtual GLsizei height() const OVERRIDE {
  56     return renderbuffer_->height();
  57   }
  58
  59   virtual GLenum internal_format() const OVERRIDE {
  60     return renderbuffer_->internal_format();
  61   }
  62
  63   virtual GLenum texture_type() const OVERRIDE {
  64     return 0;
  65   }
  66
  67   virtual GLsizei samples() const OVERRIDE {
  68     return renderbuffer_->samples();
  69   }
  70
  71   virtual GLuint object_name() const OVERRIDE {
  72     return renderbuffer_->client_id();
  73   }
  74
  75   virtual bool cleared() const OVERRIDE {
  76     return renderbuffer_->cleared();
  77   }
  78
  79   virtual void SetCleared(
  80       RenderbufferManager* renderbuffer_manager,
  81       TextureManager* /* texture_manager */,
  82       bool cleared) OVERRIDE {
  83     renderbuffer_manager->SetCleared(renderbuffer_.get(), cleared);
  84   }
  85
  86   virtual bool IsTexture(
  87       TextureRef* /* texture */) const OVERRIDE {
  88     return false;
  89   }
  90
  91   virtual bool IsRenderbuffer(
  92        Renderbuffer* renderbuffer) const OVERRIDE {
  93     return renderbuffer_.get() == renderbuffer;
  94   }
  95
  96   virtual bool CanRenderTo() const OVERRIDE {
  97     return true;
  98   }
  99
 100   virtual void DetachFromFramebuffer(Framebuffer* framebuffer) const OVERRIDE {
 101     // Nothing to do for renderbuffers.
 102   }
 103
 104   virtual bool ValidForAttachmentType(
 105       GLenum attachment_type, uint32 max_color_attachments) OVERRIDE {
 106     uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
 107         attachment_type, max_color_attachments);
 108     uint32 have = GLES2Util::GetChannelsForFormat(internal_format());
 109     return (need & have) != 0;
 110   }
 111
 112   Renderbuffer* renderbuffer() const {
 113     return renderbuffer_.get();
 114   }
 115
 116   virtual void AddToSignature(
 117       TextureManager* texture_manager, std::string* signature) const OVERRIDE {
 118     DCHECK(signature);
 119     renderbuffer_->AddToSignature(signature);
 120   }
 121
 122   virtual void OnWillRenderTo() const OVERRIDE {}
 123   virtual void OnDidRenderTo() const OVERRIDE {}
 124
 125  protected:
 126   virtual ~RenderbufferAttachment() { }
 127
 128  private:
 129   scoped_refptr<Renderbuffer> renderbuffer_;
 130
 131   DISALLOW_COPY_AND_ASSIGN(RenderbufferAttachment);
 132 };
 133
 134 class TextureAttachment
 135     : public Framebuffer::Attachment {
 136  public:
 137   TextureAttachment(
 138       TextureRef* texture_ref, GLenum target, GLint level, GLsizei samples)
 139       : texture_ref_(texture_ref),
 140         target_(target),
 141         level_(level),
 142         samples_(samples) {
 143   }
 144
 145   virtual GLsizei width() const OVERRIDE {
 146     GLsizei temp_width = 0;
 147     GLsizei temp_height = 0;
 148     texture_ref_->texture()->GetLevelSize(
 149         target_, level_, &temp_width, &temp_height);
 150     return temp_width;
 151   }
 152
 153   virtual GLsizei height() const OVERRIDE {
 154     GLsizei temp_width = 0;
 155     GLsizei temp_height = 0;
 156     texture_ref_->texture()->GetLevelSize(
 157         target_, level_, &temp_width, &temp_height);
 158     return temp_height;
 159   }
 160
 161   virtual GLenum internal_format() const OVERRIDE {
 162     GLenum temp_type = 0;
 163     GLenum temp_internal_format = 0;
 164     texture_ref_->texture()->GetLevelType(
 165         target_, level_, &temp_type, &temp_internal_format);
 166     return temp_internal_format;
 167   }
 168
 169   virtual GLenum texture_type() const OVERRIDE {
 170     GLenum temp_type = 0;
 171     GLenum temp_internal_format = 0;
 172     texture_ref_->texture()->GetLevelType(
 173         target_, level_, &temp_type, &temp_internal_format);
 174     return temp_type;
 175   }
 176
 177   virtual GLsizei samples() const OVERRIDE {
 178     return samples_;
 179   }
 180
 181   virtual GLuint object_name() const OVERRIDE {
 182     return texture_ref_->client_id();
 183   }
 184
 185   virtual bool cleared() const OVERRIDE {
 186     return texture_ref_->texture()->IsLevelCleared(target_, level_);
 187   }
 188
 189   virtual void SetCleared(
 190       RenderbufferManager* /* renderbuffer_manager */,
 191       TextureManager* texture_manager,
 192       bool cleared) OVERRIDE {
 193     texture_manager->SetLevelCleared(
 194         texture_ref_.get(), target_, level_, cleared);
 195   }
 196
 197   virtual bool IsTexture(TextureRef* texture) const OVERRIDE {
 198     return texture == texture_ref_.get();
 199   }
 200
 201   virtual bool IsRenderbuffer(
 202        Renderbuffer* /* renderbuffer */)
 203           const OVERRIDE {
 204     return false;
 205   }
 206
 207   TextureRef* texture() const {
 208     return texture_ref_.get();
 209   }
 210
 211   virtual bool CanRenderTo() const OVERRIDE {
 212     return texture_ref_->texture()->CanRenderTo();
 213   }
 214
 215   virtual void DetachFromFramebuffer(Framebuffer* framebuffer)
 216       const OVERRIDE {
 217     texture_ref_->texture()->DetachFromFramebuffer();
 218     framebuffer->OnTextureRefDetached(texture_ref_.get());
 219   }
 220
 221   virtual bool ValidForAttachmentType(
 222       GLenum attachment_type, uint32 max_color_attachments) OVERRIDE {
 223     GLenum type = 0;
 224     GLenum internal_format = 0;
 225     if (!texture_ref_->texture()->GetLevelType(
 226         target_, level_, &type, &internal_format)) {
 227       return false;
 228     }
 229     uint32 need = GLES2Util::GetChannelsNeededForAttachmentType(
 230         attachment_type, max_color_attachments);
 231     uint32 have = GLES2Util::GetChannelsForFormat(internal_format);
 232
 233     // Workaround for NVIDIA drivers that incorrectly expose these formats as
 234     // renderable:
 235     if (internal_format == GL_LUMINANCE || internal_format == GL_ALPHA ||
 236         internal_format == GL_LUMINANCE_ALPHA) {
 237       return false;
 238     }
 239     return (need & have) != 0;
 240   }
 241
 242   virtual void AddToSignature(
 243       TextureManager* texture_manager, std::string* signature) const OVERRIDE {
 244     DCHECK(signature);
 245     texture_manager->AddToSignature(
 246         texture_ref_.get(), target_, level_, signature);
 247   }
 248
 249   virtual void OnWillRenderTo() const OVERRIDE {
 250     texture_ref_->texture()->OnWillModifyPixels();
 251   }
 252
 253   virtual void OnDidRenderTo() const OVERRIDE {
 254     texture_ref_->texture()->OnDidModifyPixels();
 255   }
 256
 257  protected:
 258   virtual ~TextureAttachment() {}
 259
 260  private:
 261   scoped_refptr<TextureRef> texture_ref_;
 262   GLenum target_;
 263   GLint level_;
 264   GLsizei samples_;
 265
 266   DISALLOW_COPY_AND_ASSIGN(TextureAttachment);
 267 };
 268
 269 FramebufferManager::TextureDetachObserver::TextureDetachObserver() {}
 270
 271 FramebufferManager::TextureDetachObserver::~TextureDetachObserver() {}
 272
 273 FramebufferManager::FramebufferManager(
 274     uint32 max_draw_buffers, uint32 max_color_attachments)
 275     : framebuffer_state_change_count_(1),
 276       framebuffer_count_(0),
 277       have_context_(true),
 278       max_draw_buffers_(max_draw_buffers),
 279       max_color_attachments_(max_color_attachments) {
 280   DCHECK_GT(max_draw_buffers_, 0u);
 281   DCHECK_GT(max_color_attachments_, 0u);
 282 }
 283
 284 FramebufferManager::~FramebufferManager() {
 285   DCHECK(framebuffers_.empty());
 286   // If this triggers, that means something is keeping a reference to a
 287   // Framebuffer belonging to this.
 288   CHECK_EQ(framebuffer_count_, 0u);
 289 }
 290
 291 void Framebuffer::MarkAsDeleted() {
 292   deleted_ = true;
 293   while (!attachments_.empty()) {
 294     Attachment* attachment = attachments_.begin()->second.get();
 295     attachment->DetachFromFramebuffer(this);
 296     attachments_.erase(attachments_.begin());
 297   }
 298 }
 299
 300 void FramebufferManager::Destroy(bool have_context) {
 301   have_context_ = have_context;
 302   framebuffers_.clear();
 303 }
 304
 305 void FramebufferManager::StartTracking(
 306     Framebuffer* /* framebuffer */) {
 307   ++framebuffer_count_;
 308 }
 309
 310 void FramebufferManager::StopTracking(
 311     Framebuffer* /* framebuffer */) {
 312   --framebuffer_count_;
 313 }
 314
 315 void FramebufferManager::CreateFramebuffer(
 316     GLuint client_id, GLuint service_id) {
 317   std::pair<FramebufferMap::iterator, bool> result =
 318       framebuffers_.insert(
 319           std::make_pair(
 320               client_id,
 321               scoped_refptr<Framebuffer>(
 322                   new Framebuffer(this, service_id))));
 323   DCHECK(result.second);
 324 }
 325
 326 Framebuffer::Framebuffer(
 327     FramebufferManager* manager, GLuint service_id)
 328     : manager_(manager),
 329       deleted_(false),
 330       service_id_(service_id),
 331       has_been_bound_(false),
 332       framebuffer_complete_state_count_id_(0) {
 333   manager->StartTracking(this);
 334   DCHECK_GT(manager->max_draw_buffers_, 0u);
 335   draw_buffers_.reset(new GLenum[manager->max_draw_buffers_]);
 336   draw_buffers_[0] = GL_COLOR_ATTACHMENT0;
 337   for (uint32 i = 1; i < manager->max_draw_buffers_; ++i)
 338     draw_buffers_[i] = GL_NONE;
 339 }
 340
 341 Framebuffer::~Framebuffer() {
 342   if (manager_) {
 343     if (manager_->have_context_) {
 344       GLuint id = service_id();
 345       glDeleteFramebuffersEXT(1, &id);
 346     }
 347     manager_->StopTracking(this);
 348     manager_ = NULL;
 349   }
 350 }
 351
 352 bool Framebuffer::HasUnclearedAttachment(
 353     GLenum attachment) const {
 354   AttachmentMap::const_iterator it =
 355       attachments_.find(attachment);
 356   if (it != attachments_.end()) {
 357     const Attachment* attachment = it->second.get();
 358     return !attachment->cleared();
 359   }
 360   return false;
 361 }
 362
 363 bool Framebuffer::HasUnclearedColorAttachments() const {
 364   for (AttachmentMap::const_iterator it = attachments_.begin();
 365        it != attachments_.end(); ++it) {
 366     if (it->first >= GL_COLOR_ATTACHMENT0 &&
 367         it->first < GL_COLOR_ATTACHMENT0 + manager_->max_draw_buffers_) {
 368       const Attachment* attachment = it->second.get();
 369       if (!attachment->cleared())
 370         return true;
 371     }
 372   }
 373   return false;
 374 }
 375
 376 void Framebuffer::ChangeDrawBuffersHelper(bool recover) const {
 377   scoped_ptr<GLenum[]> buffers(new GLenum[manager_->max_draw_buffers_]);
 378   for (uint32 i = 0; i < manager_->max_draw_buffers_; ++i)
 379     buffers[i] = GL_NONE;
 380   for (AttachmentMap::const_iterator it = attachments_.begin();
 381        it != attachments_.end(); ++it) {
 382     if (it->first >= GL_COLOR_ATTACHMENT0 &&
 383         it->first < GL_COLOR_ATTACHMENT0 + manager_->max_draw_buffers_) {
 384       buffers[it->first - GL_COLOR_ATTACHMENT0] = it->first;
 385     }
 386   }
 387   bool different = false;
 388   for (uint32 i = 0; i < manager_->max_draw_buffers_; ++i) {
 389     if (buffers[i] != draw_buffers_[i]) {
 390       different = true;
 391       break;
 392     }
 393   }
 394   if (different) {
 395     if (recover)
 396       glDrawBuffersARB(manager_->max_draw_buffers_, draw_buffers_.get());
 397     else
 398       glDrawBuffersARB(manager_->max_draw_buffers_, buffers.get());
 399   }
 400 }
 401
 402 void Framebuffer::PrepareDrawBuffersForClear() const {
 403   bool recover = false;
 404   ChangeDrawBuffersHelper(recover);
 405 }
 406
 407 void Framebuffer::RestoreDrawBuffersAfterClear() const {
 408   bool recover = true;
 409   ChangeDrawBuffersHelper(recover);
 410 }
 411
 412 void Framebuffer::MarkAttachmentAsCleared(
 413       RenderbufferManager* renderbuffer_manager,
 414       TextureManager* texture_manager,
 415       GLenum attachment,
 416       bool cleared) {
 417   AttachmentMap::iterator it = attachments_.find(attachment);
 418   if (it != attachments_.end()) {
 419     Attachment* a = it->second.get();
 420     if (a->cleared() != cleared) {
 421       a->SetCleared(renderbuffer_manager,
 422                     texture_manager,
 423                     cleared);
 424     }
 425   }
 426 }
 427
 428 void Framebuffer::MarkAttachmentsAsCleared(
 429       RenderbufferManager* renderbuffer_manager,
 430       TextureManager* texture_manager,
 431       bool cleared) {
 432   for (AttachmentMap::iterator it = attachments_.begin();
 433        it != attachments_.end(); ++it) {
 434     Attachment* attachment = it->second.get();
 435     if (attachment->cleared() != cleared) {
 436       attachment->SetCleared(renderbuffer_manager, texture_manager, cleared);
 437     }
 438   }
 439 }
 440
 441 bool Framebuffer::HasDepthAttachment() const {
 442   return attachments_.find(GL_DEPTH_STENCIL_ATTACHMENT) != attachments_.end() ||
 443          attachments_.find(GL_DEPTH_ATTACHMENT) != attachments_.end();
 444 }
 445
 446 bool Framebuffer::HasStencilAttachment() const {
 447   return attachments_.find(GL_DEPTH_STENCIL_ATTACHMENT) != attachments_.end() ||
 448          attachments_.find(GL_STENCIL_ATTACHMENT) != attachments_.end();
 449 }
 450
 451 GLenum Framebuffer::GetColorAttachmentFormat() const {
 452   AttachmentMap::const_iterator it = attachments_.find(GL_COLOR_ATTACHMENT0);
 453   if (it == attachments_.end()) {
 454     return 0;
 455   }
 456   const Attachment* attachment = it->second.get();
 457   return attachment->internal_format();
 458 }
 459
 460 GLenum Framebuffer::GetColorAttachmentTextureType() const {
 461   AttachmentMap::const_iterator it = attachments_.find(GL_COLOR_ATTACHMENT0);
 462   if (it == attachments_.end()) {
 463     return 0;
 464   }
 465   const Attachment* attachment = it->second.get();
 466   return attachment->texture_type();
 467 }
 468
 469 GLenum Framebuffer::IsPossiblyComplete() const {
 470   if (attachments_.empty()) {
 471     return GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT;
 472   }
 473
 474   GLsizei width = -1;
 475   GLsizei height = -1;
 476   for (AttachmentMap::const_iterator it = attachments_.begin();
 477        it != attachments_.end(); ++it) {
 478     GLenum attachment_type = it->first;
 479     Attachment* attachment = it->second.get();
 480     if (!attachment->ValidForAttachmentType(attachment_type,
 481                                             manager_->max_color_attachments_)) {
 482       return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
 483     }
 484     if (width < 0) {
 485       width = attachment->width();
 486       height = attachment->height();
 487       if (width == 0 || height == 0) {
 488         return GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT;
 489       }
 490     } else {
 491       if (attachment->width() != width || attachment->height() != height) {
 492         return GL_FRAMEBUFFER_INCOMPLETE_DIMENSIONS_EXT;
 493       }
 494     }
 495
 496     if (!attachment->CanRenderTo()) {
 497       return GL_FRAMEBUFFER_UNSUPPORTED;
 498     }
 499   }
 500
 501   // This does not mean the framebuffer is actually complete. It just means our
 502   // checks passed.
 503   return GL_FRAMEBUFFER_COMPLETE;
 504 }
 505
 506 GLenum Framebuffer::GetStatus(
 507     TextureManager* texture_manager, GLenum target) const {
 508   // Check if we have this combo already.
 509   std::string signature;
 510   if (allow_framebuffer_combo_complete_map_) {
 511     signature = base::StringPrintf("|FBO|target=%04x", target);
 512     for (AttachmentMap::const_iterator it = attachments_.begin();
 513          it != attachments_.end(); ++it) {
 514       Attachment* attachment = it->second.get();
 515       signature +=
 516           base::StringPrintf("|Attachment|attachmentpoint=%04x", it->first);
 517       attachment->AddToSignature(texture_manager, &signature);
 518     }
 519
 520     if (!framebuffer_combo_complete_map_) {
 521       framebuffer_combo_complete_map_ = new FramebufferComboCompleteMap();
 522     }
 523
 524     FramebufferComboCompleteMap::const_iterator it =
 525         framebuffer_combo_complete_map_->find(signature);
 526     if (it != framebuffer_combo_complete_map_->end()) {
 527       return GL_FRAMEBUFFER_COMPLETE;
 528     }
 529   }
 530
 531   GLenum result = glCheckFramebufferStatusEXT(target);
 532
 533   // Insert the new result into the combo map.
 534   if (allow_framebuffer_combo_complete_map_ &&
 535       result == GL_FRAMEBUFFER_COMPLETE) {
 536     framebuffer_combo_complete_map_->insert(std::make_pair(signature, true));
 537   }
 538
 539   return result;
 540 }
 541
 542 bool Framebuffer::IsCleared() const {
 543   // are all the attachments cleaared?
 544   for (AttachmentMap::const_iterator it = attachments_.begin();
 545        it != attachments_.end(); ++it) {
 546     Attachment* attachment = it->second.get();
 547     if (!attachment->cleared()) {
 548       return false;
 549     }
 550   }
 551   return true;
 552 }
 553
 554 GLenum Framebuffer::GetDrawBuffer(GLenum draw_buffer) const {
 555   GLsizei index = static_cast<GLsizei>(
 556       draw_buffer - GL_DRAW_BUFFER0_ARB);
 557   CHECK(index >= 0 &&
 558         index < static_cast<GLsizei>(manager_->max_draw_buffers_));
 559   return draw_buffers_[index];
 560 }
 561
 562 void Framebuffer::SetDrawBuffers(GLsizei n, const GLenum* bufs) {
 563   DCHECK(n <= static_cast<GLsizei>(manager_->max_draw_buffers_));
 564   for (GLsizei i = 0; i < n; ++i)
 565     draw_buffers_[i] = bufs[i];
 566 }
 567
 568
 569
 570 bool Framebuffer::HasAlphaMRT() const {
 571   for (uint32 i = 0; i < manager_->max_draw_buffers_; ++i) {
 572     if (draw_buffers_[i] != GL_NONE) {
 573       const Attachment* attachment = GetAttachment(draw_buffers_[i]);
 574       if (!attachment)
 575         continue;
 576       if ((GLES2Util::GetChannelsForFormat(
 577                attachment->internal_format()) & 0x0008) != 0)
 578         return true;
 579     }
 580   }
 581   return false;
 582 }
 583
 584 void Framebuffer::UnbindRenderbuffer(
 585     GLenum target, Renderbuffer* renderbuffer) {
 586   bool done;
 587   do {
 588     done = true;
 589     for (AttachmentMap::const_iterator it = attachments_.begin();
 590          it != attachments_.end(); ++it) {
 591       Attachment* attachment = it->second.get();
 592       if (attachment->IsRenderbuffer(renderbuffer)) {
 593         // TODO(gman): manually detach renderbuffer.
 594         // glFramebufferRenderbufferEXT(target, it->first, GL_RENDERBUFFER, 0);
 595         AttachRenderbuffer(it->first, NULL);
 596         done = false;
 597         break;
 598       }
 599     }
 600   } while (!done);
 601 }
 602
 603 void Framebuffer::UnbindTexture(
 604     GLenum target, TextureRef* texture_ref) {
 605   bool done;
 606   do {
 607     done = true;
 608     for (AttachmentMap::const_iterator it = attachments_.begin();
 609          it != attachments_.end(); ++it) {
 610       Attachment* attachment = it->second.get();
 611       if (attachment->IsTexture(texture_ref)) {
 612         // TODO(gman): manually detach texture.
 613         // glFramebufferTexture2DEXT(target, it->first, GL_TEXTURE_2D, 0, 0);
 614         AttachTexture(it->first, NULL, GL_TEXTURE_2D, 0, 0);
 615         done = false;
 616         break;
 617       }
 618     }
 619   } while (!done);
 620 }
 621
 622 Framebuffer* FramebufferManager::GetFramebuffer(
 623     GLuint client_id) {
 624   FramebufferMap::iterator it = framebuffers_.find(client_id);
 625   return it != framebuffers_.end() ? it->second.get() : NULL;
 626 }
 627
 628 void FramebufferManager::RemoveFramebuffer(GLuint client_id) {
 629   FramebufferMap::iterator it = framebuffers_.find(client_id);
 630   if (it != framebuffers_.end()) {
 631     it->second->MarkAsDeleted();
 632     framebuffers_.erase(it);
 633   }
 634 }
 635
 636 void Framebuffer::AttachRenderbuffer(
 637     GLenum attachment, Renderbuffer* renderbuffer) {
 638   const Attachment* a = GetAttachment(attachment);
 639   if (a)
 640     a->DetachFromFramebuffer(this);
 641   if (renderbuffer) {
 642     attachments_[attachment] = scoped_refptr<Attachment>(
 643         new RenderbufferAttachment(renderbuffer));
 644   } else {
 645     attachments_.erase(attachment);
 646   }
 647   framebuffer_complete_state_count_id_ = 0;
 648 }
 649
 650 void Framebuffer::AttachTexture(
 651     GLenum attachment, TextureRef* texture_ref, GLenum target,
 652     GLint level, GLsizei samples) {
 653   const Attachment* a = GetAttachment(attachment);
 654   if (a)
 655     a->DetachFromFramebuffer(this);
 656   if (texture_ref) {
 657     attachments_[attachment] = scoped_refptr<Attachment>(
 658         new TextureAttachment(texture_ref, target, level, samples));
 659     texture_ref->texture()->AttachToFramebuffer();
 660   } else {
 661     attachments_.erase(attachment);
 662   }
 663   framebuffer_complete_state_count_id_ = 0;
 664 }
 665
 666 const Framebuffer::Attachment*
 667     Framebuffer::GetAttachment(
 668         GLenum attachment) const {
 669   AttachmentMap::const_iterator it = attachments_.find(attachment);
 670   if (it != attachments_.end()) {
 671     return it->second.get();
 672   }
 673   return NULL;
 674 }
 675
 676 void Framebuffer::OnTextureRefDetached(TextureRef* texture) {
 677   manager_->OnTextureRefDetached(texture);
 678 }
 679
 680 void Framebuffer::OnWillRenderTo() const {
 681   for (AttachmentMap::const_iterator it = attachments_.begin();
 682        it != attachments_.end(); ++it) {
 683     it->second->OnWillRenderTo();
 684   }
 685 }
 686
 687 void Framebuffer::OnDidRenderTo() const {
 688   for (AttachmentMap::const_iterator it = attachments_.begin();
 689        it != attachments_.end(); ++it) {
 690     it->second->OnDidRenderTo();
 691   }
 692 }
 693
 694 bool FramebufferManager::GetClientId(
 695     GLuint service_id, GLuint* client_id) const {
 696   // This doesn't need to be fast. It's only used during slow queries.
 697   for (FramebufferMap::const_iterator it = framebuffers_.begin();
 698        it != framebuffers_.end(); ++it) {
 699     if (it->second->service_id() == service_id) {
 700       *client_id = it->first;
 701       return true;
 702     }
 703   }
 704   return false;
 705 }
 706
 707 void FramebufferManager::MarkAttachmentsAsCleared(
 708     Framebuffer* framebuffer,
 709     RenderbufferManager* renderbuffer_manager,
 710     TextureManager* texture_manager) {
 711   DCHECK(framebuffer);
 712   framebuffer->MarkAttachmentsAsCleared(renderbuffer_manager,
 713                                         texture_manager,
 714                                         true);
 715   MarkAsComplete(framebuffer);
 716 }
 717
 718 void FramebufferManager::MarkAsComplete(
 719     Framebuffer* framebuffer) {
 720   DCHECK(framebuffer);
 721   framebuffer->MarkAsComplete(framebuffer_state_change_count_);
 722 }
 723
 724 bool FramebufferManager::IsComplete(
 725     Framebuffer* framebuffer) {
 726   DCHECK(framebuffer);
 727   return framebuffer->framebuffer_complete_state_count_id() ==
 728       framebuffer_state_change_count_;
 729 }
 730
 731 void FramebufferManager::OnTextureRefDetached(TextureRef* texture) {
 732   for (TextureDetachObserverVector::iterator it =
 733            texture_detach_observers_.begin();
 734        it != texture_detach_observers_.end();
 735        ++it) {
 736     TextureDetachObserver* observer = *it;
 737     observer->OnTextureRefDetachedFromFramebuffer(texture);
 738   }
 739 }
 740
 741 }  // namespace gles2
 742 }  // namespace gpu
 743
 744