Skip drawing unsupported layers in forced software mode

cc/layers/video_layer_impl.cc

 // Copyright 2011 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/video_layer_impl.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "cc/layers/quad_sink.h"
 #include "cc/layers/video_frame_provider_client_impl.h"
@@ skipping 51 matching lines @@
   LayerImpl::PushPropertiesTo(layer);
 
   VideoLayerImpl* other = static_cast<VideoLayerImpl*>(layer);
   other->SetProviderClientImpl(provider_client_impl_);
 }
 
 void VideoLayerImpl::DidBecomeActive() {
   provider_client_impl_->set_active_video_layer(this);
 }
 
-void VideoLayerImpl::WillDraw(ResourceProvider* resource_provider) {
-  LayerImpl::WillDraw(resource_provider);
+bool VideoLayerImpl::WillDraw(DrawMode draw_mode,
+                              ResourceProvider* resource_provider) {
+  if (draw_mode == DRAW_MODE_RESOURCELESS_SOFTWARE)
+    return false;
 
   // Explicitly acquire and release the provider mutex so it can be held from
   // WillDraw to DidDraw. Since the compositor thread is in the middle of
   // drawing, the layer will not be destroyed before DidDraw is called.
   // Therefore, the only thing that will prevent this lock from being released
   // is the GPU process locking it. As the GPU process can't cause the
   // destruction of the provider (calling StopUsingProvider), holding this
   // lock should not cause a deadlock.
   frame_ = provider_client_impl_->AcquireLockAndCurrentFrame();
 
   if (!frame_.get()) {
     // Drop any resources used by the updater if there is no frame to display.
     updater_.reset();
 
     provider_client_impl_->ReleaseLock();
-    return;
+    return false;
   }
 
+  LayerImpl::WillDraw(draw_mode, resource_provider);

[danakj, 2013/06/04 15:30:44]

In other layers we always return this value. Should we return false here if this
returns false?

+
   if (!updater_)
     updater_.reset(new VideoResourceUpdater(resource_provider));
 
   VideoFrameExternalResources external_resources;
   if (frame_->format() == media::VideoFrame::NATIVE_TEXTURE)
     external_resources = updater_->CreateForHardwarePlanes(frame_);
   else
     external_resources = updater_->CreateForSoftwarePlanes(frame_);
 
   frame_resource_type_ = external_resources.type;
 
   if (external_resources.type ==
       VideoFrameExternalResources::SOFTWARE_RESOURCE) {
     software_resources_ = external_resources.software_resources;
     software_release_callback_ =
         external_resources.software_release_callback;
-    return;
+    return true;
   }
 
   if (external_resources.hardware_resource) {
     hardware_resource_ = external_resources.hardware_resource;
     hardware_release_callback_ =
         external_resources.hardware_release_callback;
-    return;
+    return true;
   }
 
   for (size_t i = 0; i < external_resources.mailboxes.size(); ++i) {
     frame_resources_.push_back(
         resource_provider->CreateResourceFromTextureMailbox(
             external_resources.mailboxes[i]));
   }
+
+  return true;
 }
 
 void VideoLayerImpl::AppendQuads(QuadSink* quad_sink,
                                  AppendQuadsData* append_quads_data) {
-  if (!frame_.get())
-    return;
+  DCHECK(frame_.get());
 
   SharedQuadState* shared_quad_state =
       quad_sink->UseSharedQuadState(CreateSharedQuadState());
   AppendDebugBorderQuad(quad_sink, shared_quad_state, append_quads_data);
 
   gfx::Rect quad_rect(content_bounds());
   gfx::Rect opaque_rect(contents_opaque() ? quad_rect : gfx::Rect());
   gfx::Rect visible_rect = frame_->visible_rect();
   gfx::Size coded_size = frame_->coded_size();
 
@@ skipping 134 matching lines @@
 #endif
     case VideoFrameExternalResources::NONE:
       NOTIMPLEMENTED();
       break;
   }
 }
 
 void VideoLayerImpl::DidDraw(ResourceProvider* resource_provider) {
   LayerImpl::DidDraw(resource_provider);
 
-  if (!frame_.get())
-    return;
+  DCHECK(frame_.get());
 
   if (frame_resource_type_ ==
       VideoFrameExternalResources::SOFTWARE_RESOURCE) {
     for (size_t i = 0; i < software_resources_.size(); ++i)
       software_release_callback_.Run(0, false);
 
     software_resources_.clear();
     software_release_callback_.Reset();
   } else if (hardware_resource_) {
     hardware_release_callback_.Run(0, false);
@@ skipping 23 matching lines @@
 void VideoLayerImpl::SetProviderClientImpl(
     scoped_refptr<VideoFrameProviderClientImpl> provider_client_impl) {
   provider_client_impl_ = provider_client_impl;
 }
 
 const char* VideoLayerImpl::LayerTypeAsString() const {
   return "cc::VideoLayerImpl";
 }
 
 }  // namespace cc