Animate the accessibility focus ring and fix some minor visual issues.

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 "ash/display/display_controller.h"
+#include "ash/shell.h"
+#include "base/logging.h"
 #include "chrome/browser/chromeos/ui/focus_ring_layer.h"
+#include "ui/gfx/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 = 16;
+const int kAccessibilityFocusRingMargin = 7;
+
+// Time to transition between one location and the next.
+const int kTransitionTimeMilliseconds = 300;
 
 // A Region is an unordered collection of Rects that maintains its
 // bounding box. Used in the middle of an algorithm that groups
 // adjacent and overlapping rects.
 struct Region {
   explicit Region(gfx::Rect initial_rect) {
     bounds = initial_rect;
     rects.push_back(initial_rect);
   }
   gfx::Rect bounds;
   std::vector<gfx::Rect> rects;
 };
 
 }  // namespace
 
 // static
 AccessibilityFocusRingController*
     AccessibilityFocusRingController::GetInstance() {
   return Singleton<AccessibilityFocusRingController>::get();
 }
 
-AccessibilityFocusRingController::AccessibilityFocusRingController() {
+AccessibilityFocusRingController::AccessibilityFocusRingController()
+    : compositor_(NULL) {
 }
 
 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());
+  for (size_t i = 0; i < rings_.size(); ++i) {
+    if (!layers_[i])
+      layers_[i].reset(new AccessibilityFocusRingLayer(this));
 
-  if (!main_focus_ring_layer_)
-    main_focus_ring_layer_.reset(new AccessibilityFocusRingLayer(this));
+    if (i > 0) {
+      // Focus rings other than the first one don't animate.
+      layers_[i]->Set(rings_[i]);
+      continue;
+    }
 
-  if (!rings_.empty())
-    main_focus_ring_layer_->Set(rings_[0]);
+    gfx::Rect bounds = rings_[0].GetBounds();
+    gfx::Display display =
+      gfx::Screen::GetNativeScreen()->GetDisplayMatching(bounds);
+    aura::Window* root_window = ash::Shell::GetInstance()->display_controller()
+        ->GetRootWindowForDisplayId(display.id());
+    ui::Compositor* compositor = root_window->layer()->GetCompositor();
+    if (!compositor || root_window != layers_[0]->root_window()) {
+      layers_[0]->Set(rings_[0]);
+      if (compositor_ && compositor_->HasAnimationObserver(this)) {
+        compositor_->RemoveAnimationObserver(this);
+        compositor_ = NULL;
+      }
+      continue;
+    }
+
+    focus_change_time_ = base::TimeTicks::Now();
+    if (!compositor->HasAnimationObserver(this)) {
+      compositor_ = compositor;
+      compositor_->AddAnimationObserver(this);
+    }
+  }
 }
 
 void AccessibilityFocusRingController::RectsToRings(
-    const std::vector<gfx::Rect>& rects,
+    const std::vector<gfx::Rect>& src_rects,
     std::vector<AccessibilityFocusRing>* rings) const {
-  if (rects.empty())
+  if (src_rects.empty())
     return;
 
+  // Give all of the rects a margin.
+  std::vector<gfx::Rect> rects;
+  rects.resize(src_rects.size());
+  for (size_t i = 0; i < src_rects.size(); i++) {

[xiyuan, 2014/09/24 19:40:35]

nit: ++i

[dmazzoni, 2014/09/24 21:40:56]

Done.

+    rects[i] = src_rects[i];
+    rects[i].Inset(-kAccessibilityFocusRingMargin,
+                   -kAccessibilityFocusRingMargin);
+  }
+
   // Split the rects into contiguous regions.
   std::vector<Region> regions;
   regions.push_back(Region(rects[0]));
   for (size_t i = 1; i < rects.size(); ++i) {
     bool found = false;
     for (size_t j = 0; j < regions.size(); ++j) {
       if (Intersects(rects[i], regions[j].bounds)) {
         regions[j].rects.push_back(rects[i]);
         regions[j].bounds.Union(rects[i]);
         found = true;
@@ skipping 160 matching lines @@
   return (r2.x() <= r1.right() + slop &&
           r2.right() >= r1.x() - slop &&
           r2.y() <= r1.bottom() + slop &&
           r2.bottom() >= r1.y() - slop);
 }
 
 void AccessibilityFocusRingController::OnDeviceScaleFactorChanged() {
   Update();
 }
 
+void AccessibilityFocusRingController::OnAnimationStep(
+    base::TimeTicks timestamp) {
+  CHECK(compositor_);
+  CHECK(!rings_.empty());
+  CHECK(!layers_.empty());
+  CHECK(layers_[0]);
+
+  base::TimeDelta delta = timestamp - focus_change_time_;
+  base::TimeDelta transition_time =
+      base::TimeDelta::FromMilliseconds(kTransitionTimeMilliseconds);
+  if (delta >= transition_time) {
+    layers_[0]->Set(rings_[0]);
+    compositor_->RemoveAnimationObserver(this);
+    compositor_ = NULL;
+    return;
+  }
+
+  double fraction = delta.InSecondsF() / transition_time.InSecondsF();
+
+  // Ease-in effect.
+  fraction = pow(fraction, 0.3);
+
+  layers_[0]->Set(AccessibilityFocusRing::Interpolate(
+      previous_rings_[0], rings_[0], fraction));
+}
+
 }  // namespace chromeos