Make --enable-delegated-renderer show stuff on Mac

content/browser/compositor/delegated_frame_host.cc

 // Copyright 2014 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 "content/browser/compositor/delegated_frame_host.h"
 
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_ack.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/resources/single_release_callback.h"
 #include "cc/resources/texture_mailbox.h"
 #include "content/browser/compositor/resize_lock.h"
+#include "content/common/gpu/client/gl_helper.h"
 #include "content/port/browser/render_widget_host_view_frame_subscriber.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
 #include "skia/ext/image_operations.h"
 
 namespace content {
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHostClient
 
 bool DelegatedFrameHostClient::ShouldCreateResizeLock() {
   return GetDelegatedFrameHost()->ShouldCreateResizeLock();
 }
 
 void DelegatedFrameHostClient::RequestCopyOfOutput(
     scoped_ptr<cc::CopyOutputRequest> request) {
   return GetDelegatedFrameHost()->RequestCopyOfOutput(request.Pass());
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost
 
 DelegatedFrameHost::DelegatedFrameHost(DelegatedFrameHostClient* client)
     : client_(client),
       last_output_surface_id_(0),
       pending_delegated_ack_count_(0),
       skipped_frames_(false),
-      can_lock_compositor_(YES),
+      can_lock_compositor_(YES_CAN_LOCK),
       delegated_frame_evictor_(new DelegatedFrameEvictor(this)) {
   ImageTransportFactory::GetInstance()->AddObserver(this);
 }
 
 void DelegatedFrameHost::WasShown() {
   RenderWidgetHostImpl* host = client_->GetHost();
   delegated_frame_evictor_->SetVisible(true);
 
   if (host->is_accelerated_compositing_active() &&
       !released_front_lock_.get()) {
@@ skipping 15 matching lines @@
 
   // Listen to changes in the compositor lock state.
   ui::Compositor* compositor = client_->GetCompositor();
   if (!compositor->HasObserver(this))
     compositor->AddObserver(this);
 
   bool defer_compositor_lock =
       can_lock_compositor_ == NO_PENDING_RENDERER_FRAME ||
       can_lock_compositor_ == NO_PENDING_COMMIT;
 
-  if (can_lock_compositor_ == YES)
+  if (can_lock_compositor_ == YES_CAN_LOCK)
     can_lock_compositor_ = YES_DID_LOCK;
 
   resize_lock_ = client_->CreateResizeLock(defer_compositor_lock);
 }
 
 bool DelegatedFrameHost::ShouldCreateResizeLock() {
-  RenderWidgetHostImpl* host = client_->GetHost();
-
   // On Windows while resizing, the the resize locks makes us mis-paint a white
   // vertical strip (including the non-client area) if the content composition
   // is lagging the UI composition. So here we disable the throttling so that
   // the UI bits can draw ahead of the content thereby reducing the amount of
   // whiteout. Because this causes the content to be drawn at wrong sizes while
   // resizing we compensate by blocking the UI thread in Compositor::Draw() by
   // issuing a FinishAllRendering() if we are resizing.
-#if defined(OS_WIN)
+  // TODO(ccameron): Mac browser window resizing is incompletely implemented.
+#if defined(OS_WIN) || defined(OS_MACOSX)
   return false;
 #else
+  RenderWidgetHostImpl* host = client_->GetHost();
+
   if (resize_lock_)
     return false;
 
   if (host->should_auto_resize())
     return false;
   if (!host->is_accelerated_compositing_active())
     return false;
 
   gfx::Size desired_size = client_->DesiredFrameSize();
   if (desired_size == current_frame_size_in_dip_)
@@ skipping 609 matching lines @@
                                      finished_callback);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DelegatedFrameHost, ui::CompositorObserver implementation:
 
 void DelegatedFrameHost::OnCompositingDidCommit(
     ui::Compositor* compositor) {
   RenderWidgetHostImpl* host = client_->GetHost();
   if (can_lock_compositor_ == NO_PENDING_COMMIT) {
-    can_lock_compositor_ = YES;
+    can_lock_compositor_ = YES_CAN_LOCK;
     if (resize_lock_.get() && resize_lock_->GrabDeferredLock())
       can_lock_compositor_ = YES_DID_LOCK;
   }
   RunOnCommitCallbacks();
   if (resize_lock_ &&
       resize_lock_->expected_size() == current_frame_size_in_dip_) {
     resize_lock_.reset();
     host->WasResized();
     // We may have had a resize while we had the lock (e.g. if the lock expired,
     // or if the UI still gave us some resizes), so make sure we grab a new lock
@@ skipping 129 matching lines @@
   // that should keep our frame. old_layer will be returned to the
   // RecreateLayer caller, and should have a copy.
   if (frame_provider_.get()) {
     new_layer->SetShowDelegatedContent(frame_provider_.get(),
                                        current_frame_size_in_dip_);
   }
 }
 
 }  // namespace content