Refactor accessible focus ring code so the layers are animation observers.

chrome/browser/chromeos/ui/accessibility_focus_ring_controller.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 "chrome/browser/chromeos/ui/accessibility_focus_ring_controller.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 
-#include "ash/display/window_tree_host_manager.h"
 #include "ash/shell.h"
 #include "base/logging.h"
 #include "chrome/browser/chromeos/ui/focus_ring_layer.h"
-#include "ui/display/screen.h"
 
 namespace chromeos {
 
 namespace {
 
 // The number of pixels the focus ring is outset from the object it outlines,
 // which also determines the border radius of the rounded corners.
 // TODO(dmazzoni): take display resolution into account.
 const int kAccessibilityFocusRingMargin = 7;
 
@@ skipping 27 matching lines @@
 
 }  // namespace
 
 // static
 AccessibilityFocusRingController*
     AccessibilityFocusRingController::GetInstance() {
   return base::Singleton<AccessibilityFocusRingController>::get();
 }
 
 AccessibilityFocusRingController::AccessibilityFocusRingController()
-    : compositor_(nullptr), cursor_opacity_(0), cursor_compositor_(nullptr) {}
+    : cursor_opacity_(0) {}
 
 AccessibilityFocusRingController::~AccessibilityFocusRingController() {
 }
 
 void AccessibilityFocusRingController::SetFocusRing(
     const std::vector<gfx::Rect>& rects) {
   rects_ = rects;
   Update();
 }
 
 void AccessibilityFocusRingController::Update() {
   previous_rings_.swap(rings_);
   rings_.clear();
   RectsToRings(rects_, &rings_);
   layers_.resize(rings_.size());
   if (rings_.empty())
     return;
 
   for (size_t i = 0; i < rings_.size(); ++i) {
     if (!layers_[i])
       layers_[i] = new AccessibilityFocusRingLayer(this);
 
     if (i > 0) {
       // Focus rings other than the first one don't animate.
       layers_[i]->Set(rings_[i]);
     }
   }
 
-  ui::Compositor* compositor = CompositorForBounds(rings_[0].GetBounds());
-  if (compositor != compositor_) {
-    RemoveAnimationObservers();
-    compositor_ = compositor;
-    AddAnimationObservers();
-  }
-
-  if (compositor_ && compositor_->HasAnimationObserver(this)) {
+  if (layers_[0]->CanAnimate()) {
     focus_change_time_ = base::TimeTicks::Now();
   } else {
     // If we can't animate, set the location of the first ring.
     layers_[0]->Set(rings_[0]);
   }
 }
 
-ui::Compositor* AccessibilityFocusRingController::CompositorForBounds(
-    const gfx::Rect& bounds) {
-  display::Display display =
-      display::Screen::GetScreen()->GetDisplayMatching(bounds);
-  aura::Window* root_window = ash::Shell::GetInstance()
-                                  ->window_tree_host_manager()
-                                  ->GetRootWindowForDisplayId(display.id());
-  return root_window->layer()->GetCompositor();
-}
-
-void AccessibilityFocusRingController::RemoveAnimationObservers() {
-  if (compositor_ && compositor_->HasAnimationObserver(this))
-    compositor_->RemoveAnimationObserver(this);
-  if (cursor_compositor_ && cursor_compositor_->HasAnimationObserver(this))
-    cursor_compositor_->RemoveAnimationObserver(this);
-}
-
-void AccessibilityFocusRingController::AddAnimationObservers() {
-  if (compositor_ && !compositor_->HasAnimationObserver(this))
-    compositor_->AddAnimationObserver(this);
-  if (cursor_compositor_ && !cursor_compositor_->HasAnimationObserver(this))
-    cursor_compositor_->AddAnimationObserver(this);
-}
-
 void AccessibilityFocusRingController::SetCursorRing(
     const gfx::Point& location) {
   cursor_location_ = location;
   cursor_change_time_ = base::TimeTicks::Now();
   if (cursor_opacity_ == 0)
     cursor_start_time_ = cursor_change_time_;
 
   if (!cursor_layer_) {
     cursor_layer_.reset(new AccessibilityCursorRingLayer(
         this, kCursorRingColorRed, kCursorRingColorGreen,
         kCursorRingColorBlue));
   }
   cursor_layer_->Set(location);
-
-  ui::Compositor* compositor =
-      CompositorForBounds(gfx::Rect(location.x(), location.y(), 0, 0));
-  if (compositor != cursor_compositor_) {
-    RemoveAnimationObservers();
-    cursor_compositor_ = compositor;
-    AddAnimationObservers();
-  }
 }
 
 void AccessibilityFocusRingController::SetCaretRing(
     const gfx::Point& location) {
   caret_location_ = location;
 
   if (!caret_layer_) {
     caret_layer_.reset(new AccessibilityCursorRingLayer(
         this, kCaretRingColorRed, kCaretRingColorGreen, kCaretRingColorBlue));
   }
@@ skipping 190 matching lines @@
           r2.y() <= r1.bottom() + slop &&
           r2.bottom() >= r1.y() - slop);
 }
 
 void AccessibilityFocusRingController::OnDeviceScaleFactorChanged() {
   Update();
 }
 
 void AccessibilityFocusRingController::OnAnimationStep(
     base::TimeTicks timestamp) {
-  if (!rings_.empty() && compositor_)
+  if (!rings_.empty() && layers_[0]->CanAnimate())
     AnimateFocusRings(timestamp);
 
-  if (cursor_layer_ && cursor_compositor_)
+  if (cursor_layer_ && cursor_layer_->CanAnimate())
     AnimateCursorRing(timestamp);
 }
 
 void AccessibilityFocusRingController::AnimateFocusRings(
     base::TimeTicks timestamp) {
   CHECK(!rings_.empty());
   CHECK(!layers_.empty());
   CHECK(layers_[0]);
 
   // It's quite possible for the first 1 or 2 animation frames to be
   // for a timestamp that's earlier than the time we received the
   // focus change, so we just treat those as a delta of zero.
   if (timestamp < focus_change_time_)
     timestamp = focus_change_time_;
 
   base::TimeDelta delta = timestamp - focus_change_time_;
   base::TimeDelta transition_time =
       base::TimeDelta::FromMilliseconds(kTransitionTimeMilliseconds);
   if (delta >= transition_time) {
     layers_[0]->Set(rings_[0]);
-
-    RemoveAnimationObservers();
-    compositor_ = nullptr;
-    AddAnimationObservers();
     return;
   }
 
   double fraction = delta.InSecondsF() / transition_time.InSecondsF();
 
   // Ease-in effect.
   fraction = pow(fraction, 0.3);
 
   // Handle corner case where we're animating but we don't have previous
   // rings.
@@ skipping 33 matching lines @@
       cursor_opacity_ = 1.0;
   } else {
     cursor_opacity_ = 1.0 - (change_delta.InSecondsF() /
                              (fade_in_time + fade_out_time).InSecondsF());
     if (cursor_opacity_ < 0.0)
       cursor_opacity_ = 0.0;
   }
   cursor_layer_->SetOpacity(cursor_opacity_);
 }
 
-void AccessibilityFocusRingController::OnCompositingShuttingDown(
-    ui::Compositor* compositor) {
-  if (compositor == compositor_ || compositor == cursor_compositor_)
-    compositor->RemoveAnimationObserver(this);
-
-  if (compositor == compositor_)
-    compositor_ = nullptr;
-  if (compositor == cursor_compositor_)
-    cursor_compositor_ = nullptr;
-}
-
 }  // namespace chromeos