Mac Overlays: Add GPU back-pressure

ui/accelerated_widget_mac/display_link_mac.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 "ui/accelerated_widget_mac/display_link_mac.h"
 
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/trace_event/trace_event.h"
 
 namespace base {
 
 template<>
 struct ScopedTypeRefTraits<CVDisplayLinkRef> {
   static void Retain(CVDisplayLinkRef object) {
     CVDisplayLinkRetain(object);
   }
   static void Release(CVDisplayLinkRef object) {
     CVDisplayLinkRelease(object);
   }
 };
 
 }  // namespace base
 
 namespace ui {
 
 // static
 scoped_refptr<DisplayLinkMac> DisplayLinkMac::GetForDisplay(
     CGDirectDisplayID display_id) {
+  if (!display_id)
+    return nullptr;
+
   // Return the existing display link for this display, if it exists.
   DisplayMap::iterator found = display_map_.Get().find(display_id);
   if (found != display_map_.Get().end()) {
     return found->second;
   }
 
   CVReturn ret = kCVReturnSuccess;
 
   base::ScopedTypeRef<CVDisplayLinkRef> display_link;
   ret = CVDisplayLinkCreateWithCGDisplay(
@@ skipping 58 matching lines @@
   if (!timebase_and_interval_valid_) {
     StartOrContinueDisplayLink();
     return false;
   }
 
   *timebase = timebase_;
   *interval = interval_;
   return true;
 }
 
+base::TimeTicks DisplayLinkMac::GetNextVSyncTimeAfter(
+    const base::TimeTicks& from, double interval_fraction) {
+  if (!timebase_and_interval_valid_) {
+    StartOrContinueDisplayLink();
+    return from;
+  }
+
+  // Compute the previous vsync time.
+  base::TimeTicks previous_vsync =
+      interval_ * ((from - timebase_remainder_) / interval_) +
+      timebase_remainder_;
+
+  // Return |interval_fraction| through the next vsync.
+  return previous_vsync + (1 + interval_fraction) * interval_;
+}
+
 void DisplayLinkMac::Tick(const CVTimeStamp& cv_time) {
   TRACE_EVENT0("ui", "DisplayLinkMac::Tick");
 
   // Verify that videoRefreshPeriod is 32 bits.
   DCHECK((cv_time.videoRefreshPeriod & ~0xffffFFFFull) == 0ull);
 
   // Verify that the numerator and denominator make some sense.
   uint32 numerator = static_cast<uint32>(cv_time.videoRefreshPeriod);
   uint32 denominator = cv_time.videoTimeScale;
   if (numerator <= 0 || denominator <= 0) {
     LOG(WARNING) << "Unexpected numerator or denominator, bailing.";
     return;
   }
 
   timebase_ = base::TimeTicks::FromInternalValue(
       cv_time.hostTime / 1000);
   interval_ = base::TimeDelta::FromMicroseconds(
       1000000 * static_cast<int64>(numerator) / denominator);
+  // Compute |timebase_remainder_| to be the first vsync after time zero.
+  timebase_remainder_ =
+      timebase_ - interval_ * ((timebase_ - base::TimeTicks()) / interval_);
   timebase_and_interval_valid_ = true;
 
   StopDisplayLink();
 }
 
 void DisplayLinkMac::StartOrContinueDisplayLink() {
   if (CVDisplayLinkIsRunning(display_link_))
     return;
 
   CVReturn ret = CVDisplayLinkStart(display_link_);
@@ skipping 39 matching lines @@
   DisplayLinkMac* display_link_mac = found->second;
   display_link_mac->timebase_and_interval_valid_ = false;
 }
 
 // static
 base::LazyInstance<DisplayLinkMac::DisplayMap>
     DisplayLinkMac::display_map_ = LAZY_INSTANCE_INITIALIZER;
 
 }  // ui