Stop painting when receiving delegated frame

ui/aura/window.cc

 // Copyright (c) 2012 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/aura/window.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 479 matching lines @@
     if (!parent_rect.IsEmpty()) {
       parent_rect.Offset(bounds().origin().OffsetFromOrigin());
       parent_->SchedulePaintInRect(parent_rect);
     }
   } else if (layer() && layer()->SchedulePaint(rect)) {
     FOR_EACH_OBSERVER(
         WindowObserver, observers_, OnWindowPaintScheduled(this, rect));
   }
 }
 
+void Window::NotifyDamage(const gfx::Rect& rect) {

[enne (OOO), 2014/08/11 23:43:23]

This code is an unfortunate duplicate of Window::SchedulePaintInRect, but I'm
not sure how to encapsulate this logic any better.

[sky, 2014/08/13 20:01:01]

Is this a notification that a paint has been scheduled, or that a layer painted?
My initial reaction is that we shouldn't have this and instead the video
detector should be listening to the compositor. But it's entirely likely I'm
missing something.

[enne (OOO), 2014/08/13 23:55:45]

This is a notification that part of the screen has changed (or will, once the
delegated frame has been drawn).  It's more in the sense of "a layer painted"
than "a paint has been scheduled", but I'm not sure I'd use the word "paint" to
describe it.

I'm not sure what you mean by the detector listening to the compositor, as that
seems to me to be what it's doing.  The NotifyDamage call in DelegatedFrameHost
is essentially plumbing through the damage from the delegated frame to the
window to the detector.  How would you suggest doing this more simply?

+  if (!layer() && parent_) {
+    gfx::Rect parent_rect(bounds().size());
+    parent_rect.Intersect(rect);
+    if (!parent_rect.IsEmpty()) {
+      parent_rect.Offset(bounds().origin().OffsetFromOrigin());
+      parent_->NotifyDamage(parent_rect);
+    }
+  } else if (layer()) {
+    FOR_EACH_OBSERVER(
+        WindowObserver, observers_, OnWindowPaintScheduled(this, rect));
+  }
+}
+
 void Window::StackChildAtTop(Window* child) {
   if (children_.size() <= 1 || child == children_.back())
     return;  // In the front already.
   StackChildAbove(child, children_.back());
 }
 
 void Window::StackChildAbove(Window* child, Window* target) {
   StackChildRelativeTo(child, target, STACK_ABOVE);
 }
 
@@ skipping 933 matching lines @@
       return window;
     if (offset)
       *offset += window->bounds().OffsetFromOrigin();
   }
   if (offset)
     *offset = gfx::Vector2d();
   return NULL;
 }
 
 }  // namespace aura