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