Add gpu command buffer support for loseContextCHROMIUM

cc/layers/texture_layer.cc

 // Copyright 2010 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 "cc/layers/texture_layer.h"
 
 #include "cc/base/thread.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/layers/texture_layer_impl.h"
 #include "cc/trees/layer_tree_host.h"
@@ skipping 44 matching lines @@
   vertex_opacity_[0] = 1.0f;
   vertex_opacity_[1] = 1.0f;
   vertex_opacity_[2] = 1.0f;
   vertex_opacity_[3] = 1.0f;
 }
 
 TextureLayer::~TextureLayer() {
   if (layer_tree_host()) {
     if (texture_id_)
       layer_tree_host()->AcquireLayerTextures();
-    if (rate_limit_context_ && client_)
+    if (rate_limit_context_ && client_ && client_->Context3d())
       layer_tree_host()->StopRateLimiter(client_->Context3d());
   }
   if (own_mailbox_)
     texture_mailbox_.RunReleaseCallback(texture_mailbox_.sync_point(), false);
 }
 
 void TextureLayer::ClearClient() {
   client_ = NULL;
   if (uses_mailbox_)
     SetTextureMailbox(TextureMailbox());
@@ skipping 42 matching lines @@
 }
 
 void TextureLayer::SetPremultipliedAlpha(bool premultiplied_alpha) {
   if (premultiplied_alpha_ == premultiplied_alpha)
     return;
   premultiplied_alpha_ = premultiplied_alpha;
   SetNeedsCommit();
 }
 
 void TextureLayer::SetRateLimitContext(bool rate_limit) {
-  if (!rate_limit && rate_limit_context_ && client_ && layer_tree_host())
+  if (!rate_limit && rate_limit_context_ && client_ && client_->Context3d() &&
+      layer_tree_host())
     layer_tree_host()->StopRateLimiter(client_->Context3d());
 
   rate_limit_context_ = rate_limit;
 }
 
 void TextureLayer::SetTextureId(unsigned id) {
   DCHECK(!uses_mailbox_);
   if (texture_id_ == id)
     return;
   if (texture_id_ && layer_tree_host())
@@ skipping 17 matching lines @@
 void TextureLayer::WillModifyTexture() {
   if (layer_tree_host() && (DrawsContent() || content_committed_)) {
     layer_tree_host()->AcquireLayerTextures();
     content_committed_ = false;
   }
 }
 
 void TextureLayer::SetNeedsDisplayRect(const gfx::RectF& dirty_rect) {
   Layer::SetNeedsDisplayRect(dirty_rect);
 
-  if (rate_limit_context_ && client_ && layer_tree_host() && DrawsContent())
+  if (rate_limit_context_ && client_ && client_->Context3d() &&

[Justin Novosad, 2013/06/21 18:24:11]

I was getting test crashes right here because of lack of NULL ptr check after
context loss.  The other similar checks I added in this file are speculative. 
Do you think they are necessary?

[piman, 2013/06/21 19:05:05]

Why is the context NULL after a context loss?
Losing the context doesn't mean the context has to become NULL. It's the
responsibility of the client to keep the context around....

+      layer_tree_host() && DrawsContent())
     layer_tree_host()->StartRateLimiter(client_->Context3d());
 }
 
 void TextureLayer::SetLayerTreeHost(LayerTreeHost* host) {
   if (texture_id_ && layer_tree_host() && host != layer_tree_host())
     layer_tree_host()->AcquireLayerTextures();
   Layer::SetLayerTreeHost(host);
 }
 
 bool TextureLayer::DrawsContent() const {
   return (client_ || texture_id_ || !texture_mailbox_.IsEmpty()) &&
          !context_lost_ && Layer::DrawsContent();
 }
 
 void TextureLayer::Update(ResourceUpdateQueue* queue,
                           const OcclusionTracker* occlusion,
                           RenderingStats* stats) {
   if (client_) {
     if (uses_mailbox_) {
       TextureMailbox mailbox;
       if (client_->PrepareTextureMailbox(&mailbox))
         SetTextureMailbox(mailbox);
     } else {
       texture_id_ = client_->PrepareTexture(queue);
     }
     context_lost_ =
+        !client_->Context3d() ||
         client_->Context3d()->getGraphicsResetStatusARB() != GL_NO_ERROR;
   }
 
   needs_display_ = false;
 }
 
 void TextureLayer::PushPropertiesTo(LayerImpl* layer) {
   Layer::PushPropertiesTo(layer);
 
   TextureLayerImpl* texture_layer = static_cast<TextureLayerImpl*>(layer);
@@ skipping 22 matching lines @@
   // triple-buffered.  Single-buffered layers already prevent draws, so
   // can block too for simplicity.
   return DrawsContent();
 }
 
 bool TextureLayer::CanClipSelf() const {
   return true;
 }
 
 }  // namespace cc