Moved parent_->SchedulePaint() to Views::SetFillsBoundsOpaquely() and Views::SchedulePaint().

ui/views/view.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.
 
 #define _USE_MATH_DEFINES // For VC++ to get M_PI. This has to be first.
 
 #include "ui/views/view.h"
 
 #include <algorithm>
 #include <cmath>
@@ skipping 707 matching lines @@
 void View::SchedulePaint() {
   SchedulePaintInRect(GetLocalBounds());
 }
 
 void View::SchedulePaintInRect(const gfx::Rect& rect) {
   if (!visible_)
     return;
 
   if (layer()) {
     layer()->SchedulePaint(rect);
-  } else if (parent_) {
+  }
+
+  if (parent_ && (!layer() || !layer()->fills_bounds_opaquely())) {

[jonross, 2015/11/18 16:55:45]

This will trigger for all schedule paints on a non-opaque layer.

We really need it for the initial transition where the parent is dirty.
Subsequently parent and child should track when they get dirty.

[bruthig, 2015/11/18 17:02:48]

Agreed, I just want to make sure the following scenario is addressed then.

If the non-opaque child layer changes what is drawn, and more specifically
changes some previously opaque pixles to now be transparent, then what mechanism
causes the newly transparent pixels to be 'filled' in with the parents pixels?
In other words, the parent never became dirty here, but it does indeed need to
be painted again.

[bruthig, 2015/11/18 17:46:42]

Discussed offline.

     // Translate the requested paint rect to the parent's coordinate system
     // then pass this notification up to the parent.
     parent_->SchedulePaintInRect(ConvertRectToParent(rect));
   }
 }
 
 void View::Paint(const ui::PaintContext& parent_context) {
   if (!visible_)
     return;
   if (size().IsEmpty())
@@ skipping 638 matching lines @@
                  "width", canvas->sk_canvas()->getDevice()->width(),
                  "height", canvas->sk_canvas()->getDevice()->height());
     border_->Paint(*this, canvas);
   }
 }
 
 // Accelerated Painting --------------------------------------------------------
 
 void View::SetFillsBoundsOpaquely(bool fills_bounds_opaquely) {
   // This method should not have the side-effect of creating the layer.
-  if (layer())
+  if (layer()) {
     layer()->SetFillsBoundsOpaquely(fills_bounds_opaquely);
+    if (!fills_bounds_opaquely && parent_) {
+      // Translate the requested paint rect to the parent's coordinate system
+      // then pass this notification up to the parent.
+      parent_->SchedulePaintInRect(ConvertRectToParent(bounds_));
+    }
+  }
 }
 
 gfx::Vector2d View::CalculateOffsetToAncestorWithLayer(
     ui::Layer** layer_parent) {
   if (layer()) {
     if (layer_parent)
       *layer_parent = layer();
     return gfx::Vector2d();
   }
   if (!parent_)
@@ skipping 955 matching lines @@
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   gfx::Point widget_location(event.location());
   ConvertPointToWidget(this, &widget_location);
   widget->RunShellDrag(this, data, widget_location, drag_operations, source);
   // WARNING: we may have been deleted.
   return true;
 }
 
 }  // namespace views