Revert "Implement metalayer palette tool in ash."

This reverts commit 317adc6a.

Reason for revert: Broke the foillowing unittests. See https://luci-milo.appspot.com/buildbot/chromium.chromiumos/Linux%20ChromiumOS%20Tests%20%28dbg%29%281%29/28383.

LaserPointerControllerTest.LaserPointerPrediction
LaserPointerControllerTest.LaserPointerRenderer

Original change's description:
> Implement metalayer palette tool in ash.
> 
> Add a new "highlighter" tool using the same fast
> rendering method as laser pointer (CL extracting
> the common base class is to follow).
> 
> Bug: b:63142451
> Change-Id: Id848b77f08ae95c167c527a07aec6ccdf79f49f4
> Reviewed-on: https://chromium-review.googlesource.com/558467
> Commit-Queue: Vladislav Kaznacheev <kaznacheev@chromium.org>
> Reviewed-by: Mitsuru Oshima <oshima@chromium.org>
> Reviewed-by: Luis Hector Chavez <lhchavez@chromium.org>
> Reviewed-by: David Reveman <reveman@chromium.org>
> Reviewed-by: Jacob Dufault <jdufault@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#488688}

TBR=kaznacheev@chromium.org,reveman@chromium.org,oshima@chromium.org,lhchavez@chromium.org,jdufault@chromium.org

Change-Id: I8194c045c56777f140ff5850eb3543a23fc55027
No-Presubmit: true
No-Tree-Checks: true
No-Try: true
Bug: b:63142451
Reviewed-on: https://chromium-review.googlesource.com/582149Reviewed-by: Ojan Vafai <ojan@chromium.org>
Commit-Queue: Ojan Vafai <ojan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#488749}

ash/BUILD.gn

@@ -159,15 +159,6 @@ component("ash") {
     "gpu_support_stub.h",
     "high_contrast/high_contrast_controller.cc",
     "high_contrast/high_contrast_controller.h",
-    "highlighter/highlighter_controller.cc",
-    "highlighter/highlighter_controller.h",
-    "highlighter/highlighter_gesture_util.cc",
-    "highlighter/highlighter_gesture_util.h",
-    "highlighter/highlighter_result_view.cc",
-    "highlighter/highlighter_result_view.h",
-    "highlighter/highlighter_selection_observer.h",
-    "highlighter/highlighter_view.cc",
-    "highlighter/highlighter_view.h",
     "host/ash_window_tree_host.cc",
     "host/ash_window_tree_host.h",
     "host/ash_window_tree_host_init_params.h",
@@ -1173,7 +1164,6 @@ source_set("common_unittests") {
     "frame/caption_buttons/frame_size_button_unittest.cc",
     "frame/custom_frame_view_ash_unittest.cc",
     "frame/default_header_painter_unittest.cc",
-    "highlighter/highlighter_gesture_util_unittest.cc",
     "ime/ime_controller_unittest.cc",
     "laser/laser_pointer_controller_unittest.cc",
     "laser/laser_pointer_points_unittest.cc",

ash/highlighter/DEPS

-include_rules = [
-  "+ash/fast_ink",
-]

ash/highlighter/highlighter_controller.cc

-// Copyright 2017 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 "ash/highlighter/highlighter_controller.h"
-
-#include "ash/ash_switches.h"
-#include "ash/highlighter/highlighter_gesture_util.h"
-#include "ash/highlighter/highlighter_result_view.h"
-#include "ash/highlighter/highlighter_selection_observer.h"
-#include "ash/highlighter/highlighter_view.h"
-#include "ash/shell.h"
-#include "ash/system/palette/palette_utils.h"
-#include "base/command_line.h"
-#include "base/strings/string_number_conversions.h"
-#include "ui/display/screen.h"
-#include "ui/events/base_event_utils.h"
-#include "ui/views/widget/widget.h"
-
-namespace ash {
-
-namespace {
-
-// Adjust the height of the bounding box to match the pen tip height,
-// while keeping the same vertical center line. Adjust the width to
-// account for the pen tip width.
-gfx::RectF AdjustHorizontalStroke(const gfx::RectF& box,
-                                  const gfx::SizeF& pen_tip_size) {
-  return gfx::RectF(box.x() - pen_tip_size.width() / 2,
-                    box.CenterPoint().y() - pen_tip_size.height() / 2,
-                    box.width() + pen_tip_size.width(), pen_tip_size.height());
-}
-
-}  // namespace
-
-HighlighterController::HighlighterController() {
-  Shell::Get()->AddPreTargetHandler(this);
-}
-
-HighlighterController::~HighlighterController() {
-  Shell::Get()->RemovePreTargetHandler(this);
-}
-
-void HighlighterController::EnableHighlighter(
-    HighlighterSelectionObserver* observer) {
-  observer_ = observer;
-}
-
-void HighlighterController::DisableHighlighter() {
-  observer_ = nullptr;
-}
-
-void HighlighterController::OnTouchEvent(ui::TouchEvent* event) {
-  if (!observer_)
-    return;
-
-  if (event->pointer_details().pointer_type !=
-      ui::EventPointerType::POINTER_TYPE_PEN)
-    return;
-
-  if (event->type() != ui::ET_TOUCH_MOVED &&
-      event->type() != ui::ET_TOUCH_PRESSED &&
-      event->type() != ui::ET_TOUCH_RELEASED)
-    return;
-
-  // Find the root window that the event was captured on. We never need to
-  // switch between different root windows because it is not physically possible
-  // to seamlessly drag a finger between two displays like it is with a mouse.
-  gfx::Point event_location = event->root_location();
-  aura::Window* current_window =
-      static_cast<aura::Window*>(event->target())->GetRootWindow();
-
-  // Start a new highlighter session if the stylus is pressed but not
-  // pressed over the palette.
-  if (event->type() == ui::ET_TOUCH_PRESSED &&
-      !palette_utils::PaletteContainsPointInScreen(event_location)) {
-    DestroyHighlighterView();
-    UpdateHighlighterView(current_window, event->root_location_f(), event);
-  }
-
-  if (event->type() == ui::ET_TOUCH_MOVED && highlighter_view_)
-    UpdateHighlighterView(current_window, event->root_location_f(), event);
-
-  if (event->type() == ui::ET_TOUCH_RELEASED && highlighter_view_) {
-    const gfx::RectF box = GetBoundingBox(highlighter_view_->points());
-    const gfx::PointF pivot(box.CenterPoint());
-
-    const float scale_factor = current_window->layer()->device_scale_factor();
-
-    if (DetectHorizontalStroke(box, HighlighterView::kPenTipSize)) {
-      const gfx::Rect box_adjusted = gfx::ToEnclosingRect(
-          AdjustHorizontalStroke(box, HighlighterView::kPenTipSize));
-      observer_->HandleSelection(
-          gfx::ScaleToEnclosingRect(box_adjusted, scale_factor));
-      highlighter_view_->Animate(pivot,
-                                 HighlighterView::AnimationMode::kFadeout);
-
-      result_view_ = base::MakeUnique<HighlighterResultView>(current_window);
-      result_view_->AnimateInPlace(box_adjusted, HighlighterView::kPenColor);
-    } else if (DetectClosedShape(box, highlighter_view_->points())) {
-      const gfx::Rect box_enclosing = gfx::ToEnclosingRect(box);
-
-      observer_->HandleSelection(
-          gfx::ScaleToEnclosingRect(box_enclosing, scale_factor));
-      highlighter_view_->Animate(pivot,
-                                 HighlighterView::AnimationMode::kInflate);
-
-      result_view_ = base::MakeUnique<HighlighterResultView>(current_window);
-      result_view_->AnimateDeflate(box_enclosing);
-    } else {
-      highlighter_view_->Animate(pivot,
-                                 HighlighterView::AnimationMode::kDeflate);
-    }
-  }
-}
-
-void HighlighterController::OnWindowDestroying(aura::Window* window) {
-  SwitchTargetRootWindowIfNeeded(window);
-}
-
-void HighlighterController::SwitchTargetRootWindowIfNeeded(
-    aura::Window* root_window) {
-  if (!root_window) {
-    DestroyHighlighterView();
-  }
-
-  if (root_window && observer_ && !highlighter_view_) {
-    highlighter_view_ = base::MakeUnique<HighlighterView>(root_window);
-  }
-}
-
-void HighlighterController::UpdateHighlighterView(
-    aura::Window* current_window,
-    const gfx::PointF& event_location,
-    ui::Event* event) {
-  SwitchTargetRootWindowIfNeeded(current_window);
-  highlighter_view_->AddNewPoint(event_location);
-  event->StopPropagation();
-}
-
-void HighlighterController::DestroyHighlighterView() {
-  highlighter_view_.reset();
-  result_view_.reset();
-}
-
-}  // namespace ash

ash/highlighter/highlighter_controller.h

-// Copyright 2017 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.
-
-#ifndef ASH_HIGHLIGHTER_HIGHLIGHTER_CONTROLLER_H_
-#define ASH_HIGHLIGHTER_HIGHLIGHTER_CONTROLLER_H_
-
-#include <memory>
-
-#include "ash/ash_export.h"
-#include "base/macros.h"
-#include "base/time/time.h"
-#include "ui/aura/window_observer.h"
-#include "ui/events/event_handler.h"
-#include "ui/gfx/geometry/point_f.h"
-
-namespace ash {
-
-class HighlighterResultView;
-class HighlighterSelectionObserver;
-class HighlighterView;
-
-// Controller for the highlighter functionality.
-// Enables/disables highlighter as well as receives points
-// and passes them off to be rendered.
-class ASH_EXPORT HighlighterController : public ui::EventHandler,
-                                         public aura::WindowObserver {
- public:
-  HighlighterController();
-  ~HighlighterController() override;
-
-  // Turns the highlighter feature on. The user still has to press and
-  // drag to see the highlighter.
-  void EnableHighlighter(HighlighterSelectionObserver* observer);
-
-  void DisableHighlighter();
-
- private:
-  // ui::EventHandler:
-  void OnTouchEvent(ui::TouchEvent* event) override;
-
-  // aura::WindowObserver:
-  void OnWindowDestroying(aura::Window* window) override;
-
-  // Handles monitor disconnect/swap primary.
-  void SwitchTargetRootWindowIfNeeded(aura::Window* root_window);
-
-  // Updates |highlighter_view_| by changing its root window or creating it if
-  // needed. Also adds the latest point at |event_location| and stops
-  // propagation of |event|.
-  void UpdateHighlighterView(aura::Window* current_window,
-                             const gfx::PointF& event_location,
-                             ui::Event* event);
-
-  // Destroys |highlighter_view_|, if it exists.
-  void DestroyHighlighterView();
-
-  // |highlighter_view_| will only hold an instance when the highlighter is
-  // enabled and activated (pressed or dragged).
-  std::unique_ptr<HighlighterView> highlighter_view_;
-
-  std::unique_ptr<HighlighterResultView> result_view_;
-
-  // |observer_| in non-null when the highlighter is enabled,
-  // null when disabled.
-  HighlighterSelectionObserver* observer_;
-
-  DISALLOW_COPY_AND_ASSIGN(HighlighterController);
-};
-
-}  // namespace ash
-
-#endif  // ASH_HIGHLIGHTER_HIGHLIGHTER_CONTROLLER_H_

ash/highlighter/highlighter_gesture_util.cc

-// Copyright 2017 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 "ash/highlighter/highlighter_gesture_util.h"
-
-#include <cmath>
-
-namespace ash {
-
-const float kHorizontalStrokeLengthThreshold = 20;
-const float kHorizontalStrokeThicknessThreshold = 2;
-const float kHorizontalStrokeFlatnessThreshold = 0.1;
-
-const double kClosedShapeWrapThreshold = M_PI * 2 * 0.95;
-const double kClosedShapeSweepThreshold = M_PI * 2 * 0.8;
-const double kClosedShapeJiggleThreshold = 0.1;
-
-gfx::RectF GetBoundingBox(const std::vector<gfx::PointF>& points) {
-  if (points.empty())
-    return gfx::RectF();
-
-  gfx::PointF min_point = points[0];
-  gfx::PointF max_point = points[0];
-  for (size_t i = 1; i < points.size(); ++i) {
-    min_point.SetToMin(points[i]);
-    max_point.SetToMax(points[i]);
-  }
-
-  return gfx::BoundingRect(min_point, max_point);
-}
-
-bool DetectHorizontalStroke(const gfx::RectF& box,
-                            const gfx::SizeF& pen_tip_size) {
-  return box.width() > kHorizontalStrokeLengthThreshold &&
-         box.height() <
-             pen_tip_size.height() * kHorizontalStrokeThicknessThreshold &&
-         box.height() < box.width() * kHorizontalStrokeFlatnessThreshold;
-}
-
-bool DetectClosedShape(const gfx::RectF& box,
-                       const std::vector<gfx::PointF>& points) {
-  if (points.size() < 3)
-    return false;
-
-  const gfx::PointF center = box.CenterPoint();
-
-  // Analyze vectors pointing from the center to each point.
-  // Compute the cumulative swept angle and count positive
-  // and negative angles separately.
-  double swept_angle = 0.0;
-  int positive = 0;
-  int negative = 0;
-
-  double prev_angle = 0.0;
-  bool has_prev_angle = false;
-
-  for (const auto& point : points) {
-    const double angle = atan2(point.y() - center.y(), point.x() - center.x());
-    if (has_prev_angle) {
-      double diff_angle = angle - prev_angle;
-      if (diff_angle > kClosedShapeWrapThreshold) {
-        diff_angle -= M_PI * 2;
-      } else if (diff_angle < -kClosedShapeWrapThreshold) {
-        diff_angle += M_PI * 2;
-      }
-      swept_angle += diff_angle;
-      if (diff_angle > 0)
-        positive++;
-      if (diff_angle < 0)
-        negative++;
-    } else {
-      has_prev_angle = true;
-    }
-    prev_angle = angle;
-  }
-
-  if (std::abs(swept_angle) < kClosedShapeSweepThreshold) {
-    // Has not swept enough of the full circle.
-    return false;
-  }
-
-  if (swept_angle > 0 && (static_cast<double>(negative) / positive) >
-                             kClosedShapeJiggleThreshold) {
-    // Main direction is positive, but went too often in the negative direction.
-    return false;
-  }
-  if (swept_angle < 0 && (static_cast<double>(positive) / negative) >
-                             kClosedShapeJiggleThreshold) {
-    // Main direction is negative, but went too often in the positive direction.
-    return false;
-  }
-
-  return true;
-}
-
-}  // namespace ash

ash/highlighter/highlighter_gesture_util.h

-// Copyright 2017 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.
-
-#ifndef ASH_HIGHLIGHTER_HIGHLIGHTER_GESTURE_UTIL_H_
-#define ASH_HIGHLIGHTER_HIGHLIGHTER_GESTURE_UTIL_H_
-
-#include <vector>
-
-#include "ash/ash_export.h"
-#include "ui/gfx/geometry/rect_f.h"
-
-namespace ash {
-
-// Returns the bounding box of |points|
-gfx::RectF ASH_EXPORT GetBoundingBox(const std::vector<gfx::PointF>& points);
-
-// Returns true if |box| is sufficiently long horizontally and short vertically.
-bool ASH_EXPORT DetectHorizontalStroke(const gfx::RectF& box,
-                                       const gfx::SizeF& pen_tip_size);
-
-// Returns true if |points| is forming a "closed shape" which is defined as a
-// sequence of points sweeping at least of 80% of a full circle around the
-// center of |box|, and going in one direction (clockwise or counterclockwise),
-// with a little noise tolerated).
-bool ASH_EXPORT DetectClosedShape(const gfx::RectF& box,
-                                  const std::vector<gfx::PointF>& points);
-
-}  // namespace ash
-
-#endif  // ASH_HIGHLIGHTER_HIGHLIGHTER_GESTURE_UTIL_H_

ash/highlighter/highlighter_gesture_util_unittest.cc

-// Copyright 2017 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 "ash/highlighter/highlighter_gesture_util.h"
-#include "ash/test/ash_test_base.h"
-#include "ui/gfx/geometry/rect_conversions.h"
-
-namespace ash {
-
-namespace {
-
-constexpr float kLength = 400;
-
-constexpr gfx::RectF kFrame(50, 50, 300, 200);
-
-constexpr gfx::SizeF kPenTipSize(4.0, 14);
-
-constexpr int kPointsPerLine = 10;
-
-float LinearInterpolate(float from, float to, int position, int range) {
-  return from + ((to - from) * position) / range;
-}
-
-class HighlighterGestureUtilTest : public AshTestBase {
- public:
-  HighlighterGestureUtilTest() {}
-
-  ~HighlighterGestureUtilTest() override {}
-
- protected:
-  std::vector<gfx::PointF> points_;
-
-  void MoveTo(float x, float y) { AddPoint(x, y); }
-
-  void LineTo(float x, float y) {
-    const gfx::PointF origin = points_.back();
-    for (int i = 1; i <= kPointsPerLine; i++) {
-      AddPoint(LinearInterpolate(origin.x(), x, i, kPointsPerLine),
-               LinearInterpolate(origin.y(), y, i, kPointsPerLine));
-    }
-  }
-
-  void TraceLine(float x0, float y0, float x1, float y1) {
-    MoveTo(x0, y0);
-    LineTo(x1, y1);
-  }
-
-  void TraceRect(const gfx::RectF& rect, float tilt) {
-    MoveTo(rect.x() + tilt, rect.y());
-    LineTo(rect.right(), rect.y() + tilt);
-    LineTo(rect.right() - tilt, rect.bottom());
-    LineTo(rect.x(), rect.bottom() - tilt);
-    LineTo(rect.x() + tilt, rect.y());
-  }
-
-  void TraceZigZag(float w, float h) {
-    MoveTo(0, 0);
-    LineTo(w / 4, h);
-    LineTo(w / 2, 0);
-    LineTo(w * 3 / 4, h);
-    LineTo(w, 0);
-  }
-
-  bool DetectHorizontalStroke() {
-    gfx::RectF box = GetBoundingBox(points_);
-    return ash::DetectHorizontalStroke(box, kPenTipSize);
-  }
-
-  bool DetectClosedShape() {
-    gfx::RectF box = GetBoundingBox(points_);
-    return ash::DetectClosedShape(box, points_);
-  }
-
- private:
-  void AddPoint(float x, float y) { points_.push_back(gfx::PointF(x, y)); }
-
-  DISALLOW_COPY_AND_ASSIGN(HighlighterGestureUtilTest);
-};
-
-}  // namespace
-
-TEST_F(HighlighterGestureUtilTest, HorizontalStrokeTooShort) {
-  TraceLine(0, 0, 1, 0);
-  EXPECT_FALSE(DetectHorizontalStroke());
-  EXPECT_FALSE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, HorizontalStrokeFlat) {
-  TraceLine(0, 0, kLength, 0);
-  EXPECT_TRUE(DetectHorizontalStroke());
-  EXPECT_FALSE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, HorizontalStrokeTiltedLeftSlightly) {
-  const float kTilt = kLength / 20;
-  TraceLine(0, kTilt, kLength, 0);
-  EXPECT_TRUE(DetectHorizontalStroke());
-  EXPECT_FALSE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, HorizontalStrokeTiltedRightSlightly) {
-  const float kTilt = kLength / 20;
-  TraceLine(0, 0, kLength, kTilt);
-  EXPECT_TRUE(DetectHorizontalStroke());
-  EXPECT_FALSE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, HorizontalStrokeTiltedLeftTooMuch) {
-  const float kTilt = kLength / 5;
-  TraceLine(0, kTilt, kLength, 0);
-  EXPECT_FALSE(DetectHorizontalStroke());
-  EXPECT_FALSE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, HorizontalStrokeTiltedRightTooMuch) {
-  const float kTilt = kLength / 5;
-  TraceLine(0, 0, kLength, kTilt);
-  EXPECT_FALSE(DetectHorizontalStroke());
-  EXPECT_FALSE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, HorizontalStrokeZigZagSlightly) {
-  const float kHeight = kLength / 20;
-  TraceZigZag(kLength, kHeight);
-  EXPECT_TRUE(DetectHorizontalStroke());
-  EXPECT_FALSE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, HorizontalStrokeZigZagTooMuch) {
-  const float kHeight = kLength / 5;
-  TraceZigZag(kLength, kHeight);
-  EXPECT_FALSE(DetectHorizontalStroke());
-  EXPECT_FALSE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, ClosedShapeRectangle) {
-  TraceRect(kFrame, 0);
-  EXPECT_FALSE(DetectHorizontalStroke());
-  EXPECT_TRUE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, ClosedShapeRectangleThin) {
-  TraceRect(gfx::RectF(0, 0, kLength, kLength / 20), 0);
-  EXPECT_TRUE(DetectHorizontalStroke());
-  EXPECT_TRUE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, ClosedShapeRectangleTilted) {
-  TraceRect(kFrame, 10.0);
-  EXPECT_FALSE(DetectHorizontalStroke());
-  EXPECT_TRUE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, ClosedShapeWithOverlap) {
-  // 1/4 overlap
-  MoveTo(kFrame.right(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.bottom());
-  LineTo(kFrame.right(), kFrame.bottom());
-  LineTo(kFrame.right(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.y());
-  EXPECT_FALSE(DetectHorizontalStroke());
-  EXPECT_TRUE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, ClosedShapeLikeU) {
-  // 1/4 open shape
-  MoveTo(kFrame.x(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.bottom());
-  LineTo(kFrame.right(), kFrame.bottom());
-  LineTo(kFrame.right(), kFrame.y());
-  EXPECT_FALSE(DetectHorizontalStroke());
-  EXPECT_FALSE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, ClosedShapeLikeG) {
-  // 1/8 open shape
-  MoveTo(kFrame.right(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.bottom());
-  LineTo(kFrame.right(), kFrame.bottom());
-  LineTo(kFrame.right(), kFrame.CenterPoint().y());
-  EXPECT_FALSE(DetectHorizontalStroke());
-  EXPECT_TRUE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, ClosedShapeWithLittleBackAndForth) {
-  MoveTo(kFrame.right(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.y());
-  // Go back one pixel, then go forward again.
-  MoveTo(kFrame.x() + 1, kFrame.y());
-  MoveTo(kFrame.x(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.bottom());
-  LineTo(kFrame.right(), kFrame.bottom());
-  LineTo(kFrame.right(), kFrame.CenterPoint().y());
-  EXPECT_FALSE(DetectHorizontalStroke());
-  EXPECT_TRUE(DetectClosedShape());
-}
-
-TEST_F(HighlighterGestureUtilTest, ClosedShapeWithTooMuchBackAndForth) {
-  MoveTo(kFrame.right(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.y());
-  LineTo(kFrame.right(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.bottom());
-  LineTo(kFrame.x(), kFrame.y());
-  LineTo(kFrame.x(), kFrame.bottom());
-  LineTo(kFrame.right(), kFrame.bottom());
-  LineTo(kFrame.x(), kFrame.bottom());
-  LineTo(kFrame.right(), kFrame.bottom());
-  LineTo(kFrame.right(), kFrame.CenterPoint().y());
-  EXPECT_FALSE(DetectHorizontalStroke());
-  EXPECT_FALSE(DetectClosedShape());
-}
-
-}  // namespace ash

ash/highlighter/highlighter_result_view.cc

-// Copyright 2017 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 "ash/highlighter/highlighter_result_view.h"
-
-#include "ash/public/cpp/shell_window_ids.h"
-#include "ash/shell.h"
-#include "ui/compositor/paint_recorder.h"
-#include "ui/compositor/scoped_layer_animation_settings.h"
-#include "ui/views/widget/widget.h"
-
-namespace ash {
-
-namespace {
-
-// Variables for rendering the highlight result. Sizes in DIP.
-constexpr float kCornerCircleRadius = 6;
-constexpr float kStrokeFillWidth = 2;
-constexpr float kStrokeOutlineWidth = 1;
-constexpr float kOutsetForAntialiasing = 1;
-constexpr float kResultLayerMargin =
-    kOutsetForAntialiasing + kCornerCircleRadius;
-
-constexpr int kInnerFillOpacity = 0x0D;
-const SkColor kInnerFillColor = SkColorSetRGB(0x00, 0x00, 0x00);
-
-constexpr int kStrokeFillOpacity = 0xFF;
-const SkColor kStrokeFillColor = SkColorSetRGB(0xFF, 0xFF, 0xFF);
-
-constexpr int kStrokeOutlineOpacity = 0x14;
-const SkColor kStrokeOutlineColor = SkColorSetRGB(0x00, 0x00, 0x00);
-
-constexpr int kCornerCircleOpacity = 0xFF;
-const SkColor kCornerCircleColorLT = SkColorSetRGB(0x42, 0x85, 0xF4);
-const SkColor kCornerCircleColorRT = SkColorSetRGB(0xEA, 0x43, 0x35);
-const SkColor kCornerCircleColorLB = SkColorSetRGB(0x34, 0xA8, 0x53);
-const SkColor kCornerCircleColorRB = SkColorSetRGB(0xFB, 0xBC, 0x05);
-
-constexpr int kResultFadeinDelayMs = 600;
-constexpr int kResultFadeinDurationMs = 400;
-constexpr int kResultFadeoutDelayMs = 500;
-constexpr int kResultFadeoutDurationMs = 200;
-
-constexpr int kResultInPlaceFadeinDelayMs = 500;
-constexpr int kResultInPlaceFadeinDurationMs = 500;
-
-constexpr float kInitialScale = 1.2;
-
-class ResultLayer : public ui::Layer, public ui::LayerDelegate {
- public:
-  ResultLayer(const gfx::Rect& bounds);
-
- private:
-  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
-
-  void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
-
-  void OnPaintLayer(const ui::PaintContext& context) override;
-
-  void DrawVerticalBar(gfx::Canvas& canvas,
-                       float x,
-                       float y,
-                       float height,
-                       cc::PaintFlags& flags);
-  void DrawHorizontalBar(gfx::Canvas& canvas,
-                         float x,
-                         float y,
-                         float width,
-                         cc::PaintFlags& flags);
-
-  DISALLOW_COPY_AND_ASSIGN(ResultLayer);
-};
-
-ResultLayer::ResultLayer(const gfx::Rect& box) {
-  set_name("HighlighterResultView:ResultLayer");
-  gfx::Rect bounds = box;
-  bounds.Inset(-kResultLayerMargin, -kResultLayerMargin);
-  SetBounds(bounds);
-  SetFillsBoundsOpaquely(false);
-  SetMasksToBounds(false);
-  set_delegate(this);
-}
-
-void ResultLayer::OnPaintLayer(const ui::PaintContext& context) {
-  ui::PaintRecorder recorder(context, size());
-  gfx::Canvas& canvas = *recorder.canvas();
-
-  cc::PaintFlags flags;
-  flags.setStyle(cc::PaintFlags::kFill_Style);
-  flags.setAntiAlias(true);
-
-  const float left = kResultLayerMargin;
-  const float right = size().width() - kResultLayerMargin;
-  const float width = right - left;
-
-  const float top = kResultLayerMargin;
-  const float bottom = size().height() - kResultLayerMargin;
-  const float height = bottom - top;
-
-  flags.setColor(SkColorSetA(kInnerFillColor, kInnerFillOpacity));
-  canvas.DrawRect(gfx::RectF(left, top, width, height), flags);
-
-  DrawVerticalBar(canvas, left, top, height, flags);
-  DrawVerticalBar(canvas, right, top, height, flags);
-  DrawHorizontalBar(canvas, left, top, width, flags);
-  DrawHorizontalBar(canvas, left, bottom, width, flags);
-
-  flags.setColor(SkColorSetA(kCornerCircleColorLT, kCornerCircleOpacity));
-  canvas.DrawCircle(gfx::PointF(left, top), kCornerCircleRadius, flags);
-
-  flags.setColor(SkColorSetA(kCornerCircleColorRT, kCornerCircleOpacity));
-  canvas.DrawCircle(gfx::PointF(right, top), kCornerCircleRadius, flags);
-
-  flags.setColor(SkColorSetA(kCornerCircleColorLB, kCornerCircleOpacity));
-  canvas.DrawCircle(gfx::PointF(right, bottom), kCornerCircleRadius, flags);
-
-  flags.setColor(SkColorSetA(kCornerCircleColorRB, kCornerCircleOpacity));
-  canvas.DrawCircle(gfx::PointF(left, bottom), kCornerCircleRadius, flags);
-}
-
-void ResultLayer::DrawVerticalBar(gfx::Canvas& canvas,
-                                  float x,
-                                  float y,
-                                  float height,
-                                  cc::PaintFlags& flags) {
-  const float x_fill = x - kStrokeFillWidth / 2;
-  const float x_outline_left = x_fill - kStrokeOutlineWidth;
-  const float x_outline_right = x_fill + kStrokeFillWidth;
-
-  flags.setColor(SkColorSetA(kStrokeFillColor, kStrokeFillOpacity));
-  canvas.DrawRect(gfx::RectF(x_fill, y, kStrokeFillWidth, height), flags);
-
-  flags.setColor(SkColorSetA(kStrokeOutlineColor, kStrokeOutlineOpacity));
-  canvas.DrawRect(gfx::RectF(x_outline_left, y, kStrokeOutlineWidth, height),
-                  flags);
-  canvas.DrawRect(gfx::RectF(x_outline_right, y, kStrokeOutlineWidth, height),
-                  flags);
-}
-
-void ResultLayer::DrawHorizontalBar(gfx::Canvas& canvas,
-                                    float x,
-                                    float y,
-                                    float width,
-                                    cc::PaintFlags& flags) {
-  const float y_fill = y - kStrokeFillWidth / 2;
-  const float y_outline_left = y_fill - kStrokeOutlineWidth;
-  const float y_outline_right = y_fill + kStrokeFillWidth;
-
-  flags.setColor(SkColorSetA(kStrokeFillColor, kStrokeFillOpacity));
-  canvas.DrawRect(gfx::RectF(x, y_fill, width, kStrokeFillWidth), flags);
-
-  flags.setColor(SkColorSetA(kStrokeOutlineColor, kStrokeOutlineOpacity));
-  canvas.DrawRect(gfx::RectF(x, y_outline_left, width, kStrokeOutlineWidth),
-                  flags);
-  canvas.DrawRect(gfx::RectF(x, y_outline_right, width, kStrokeOutlineWidth),
-                  flags);
-}
-
-}  // namespace
-
-HighlighterResultView::HighlighterResultView(aura::Window* root_window) {
-  widget_ = base::MakeUnique<views::Widget>();
-
-  views::Widget::InitParams params;
-  params.type = views::Widget::InitParams::TYPE_WINDOW_FRAMELESS;
-  params.name = "HighlighterResult";
-  params.accept_events = false;
-  params.activatable = views::Widget::InitParams::ACTIVATABLE_NO;
-  params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
-  params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
-  params.parent =
-      Shell::GetContainer(root_window, kShellWindowId_OverlayContainer);
-  params.layer_type = ui::LAYER_SOLID_COLOR;
-
-  widget_->Init(params);
-  widget_->Show();
-  widget_->SetContentsView(this);
-  widget_->SetFullscreen(true);
-  set_owned_by_client();
-}
-
-HighlighterResultView::~HighlighterResultView() {}
-
-void HighlighterResultView::AnimateInPlace(const gfx::Rect& bounds,
-                                           SkColor color) {
-  ui::Layer* layer = widget_->GetLayer();
-
-  // A solid transparent rectangle.
-  result_layer_ = base::MakeUnique<ui::Layer>(ui::LAYER_SOLID_COLOR);
-  result_layer_->set_name("HighlighterResultView:SOLID_LAYER");
-  result_layer_->SetBounds(bounds);
-  result_layer_->SetFillsBoundsOpaquely(false);
-  result_layer_->SetMasksToBounds(false);
-  result_layer_->SetColor(color);
-
-  layer->Add(result_layer_.get());
-
-  ScheduleFadeIn(
-      base::TimeDelta::FromMilliseconds(kResultInPlaceFadeinDelayMs),
-      base::TimeDelta::FromMilliseconds(kResultInPlaceFadeinDurationMs));
-}
-
-void HighlighterResultView::AnimateDeflate(const gfx::Rect& bounds) {
-  ui::Layer* layer = widget_->GetLayer();
-
-  result_layer_ = base::MakeUnique<ResultLayer>(bounds);
-  layer->Add(result_layer_.get());
-
-  gfx::Transform transform;
-  const gfx::Point pivot = bounds.CenterPoint();
-  transform.Translate(pivot.x() * (1 - kInitialScale),
-                      pivot.y() * (1 - kInitialScale));
-  transform.Scale(kInitialScale, kInitialScale);
-  layer->SetTransform(transform);
-
-  ScheduleFadeIn(base::TimeDelta::FromMilliseconds(kResultFadeinDelayMs),
-                 base::TimeDelta::FromMilliseconds(kResultFadeinDurationMs));
-}
-
-void HighlighterResultView::ScheduleFadeIn(const base::TimeDelta& delay,
-                                           const base::TimeDelta& duration) {
-  ui::Layer* layer = widget_->GetLayer();
-
-  layer->SetOpacity(0);
-
-  animation_timer_.reset(
-      new base::Timer(FROM_HERE, delay,
-                      base::Bind(&HighlighterResultView::FadeIn,
-                                 base::Unretained(this), duration),
-                      false));
-  animation_timer_->Reset();
-}
-
-void HighlighterResultView::FadeIn(const base::TimeDelta& duration) {
-  ui::Layer* layer = widget_->GetLayer();
-
-  {
-    ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
-    settings.SetTransitionDuration(duration);
-    settings.SetTweenType(gfx::Tween::LINEAR_OUT_SLOW_IN);
-    layer->SetOpacity(1);
-
-    gfx::Transform transform;
-    transform.Scale(1, 1);
-    transform.Translate(0, 0);
-    layer->SetTransform(transform);
-  }
-
-  animation_timer_.reset(new base::Timer(
-      FROM_HERE,
-      base::TimeDelta::FromMilliseconds(kResultFadeinDurationMs +
-                                        kResultFadeoutDelayMs),
-      base::Bind(&HighlighterResultView::FadeOut, base::Unretained(this)),
-      false));
-  animation_timer_->Reset();
-}
-
-void HighlighterResultView::FadeOut() {
-  ui::Layer* layer = widget_->GetLayer();
-
-  ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
-  settings.SetTransitionDuration(
-      base::TimeDelta::FromMilliseconds(kResultFadeoutDurationMs));
-  settings.SetTweenType(gfx::Tween::LINEAR_OUT_SLOW_IN);
-  layer->SetOpacity(0);
-}
-
-}  // namespace ash

ash/highlighter/highlighter_result_view.h

-// Copyright 2017 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.
-
-#ifndef ASH_HIGHLIGHTER_HIGHLIGHTER_RESULT_VIEW_H_
-#define ASH_HIGHLIGHTER_HIGHLIGHTER_RESULT_VIEW_H_
-
-#include <memory>
-
-#include "base/macros.h"
-#include "ui/views/view.h"
-
-namespace aura {
-class Window;
-}
-
-namespace base {
-class Timer;
-}
-
-namespace ui {
-class Layer;
-}
-
-namespace views {
-class Widget;
-}
-
-namespace ash {
-
-// HighlighterResultView displays an animated shape that represents
-// the result of the selection.
-class HighlighterResultView : public views::View {
- public:
-  HighlighterResultView(aura::Window* root_window);
-
-  ~HighlighterResultView() override;
-
-  void AnimateInPlace(const gfx::Rect& bounds, SkColor color);
-  void AnimateDeflate(const gfx::Rect& bounds);
-
- private:
-  void ScheduleFadeIn(const base::TimeDelta& delay,
-                      const base::TimeDelta& duration);
-  void FadeIn(const base::TimeDelta& duration);
-  void FadeOut();
-
-  std::unique_ptr<views::Widget> widget_;
-  std::unique_ptr<ui::Layer> result_layer_;
-  std::unique_ptr<base::Timer> animation_timer_;
-
-  DISALLOW_COPY_AND_ASSIGN(HighlighterResultView);
-};
-
-}  // namespace ash
-
-#endif  // ASH_HIGHLIGHTER_HIGHLIGHTER_RESULT_VIEW_H_

ash/highlighter/highlighter_selection_observer.h

-// Copyright 2017 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.
-
-#ifndef ASH_HIGHLIGHTER_HIGHLIGHTER_SELECTION_OBSERVER_H_
-#define ASH_HIGHLIGHTER_HIGHLIGHTER_SELECTION_OBSERVER_H_
-
-namespace gfx {
-class Rect;
-}  // namespace gfx
-
-namespace ash {
-
-// Observer for handling highlighter selection.
-class HighlighterSelectionObserver {
- public:
-  virtual ~HighlighterSelectionObserver() {}
-
-  virtual void HandleSelection(const gfx::Rect& rect) = 0;
-};
-
-}  // namespace ash
-
-#endif  // ASH_HIGHLIGHTER_HIGHLIGHTER_SELECTION_OBSERVER_H_

ash/highlighter/highlighter_view.cc

-// Copyright 2017 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 "ash/highlighter/highlighter_view.h"
-
-#include "third_party/skia/include/core/SkColor.h"
-#include "third_party/skia/include/core/SkTypes.h"
-#include "ui/compositor/scoped_layer_animation_settings.h"
-#include "ui/gfx/canvas.h"
-#include "ui/views/widget/widget.h"
-
-namespace ash {
-namespace {
-
-// Variables for rendering the highlighter. Sizes in DIP.
-const SkColor kHighlighterColor = SkColorSetRGB(0x42, 0x85, 0xF4);
-constexpr int kHighlighterOpacity = 0xCC;
-constexpr float kPenTipWidth = 4;
-constexpr float kPenTipHeight = 14;
-constexpr int kOutsetForAntialiasing = 1;
-
-constexpr float kStrokeScale = 1.2;
-
-constexpr int kStrokeFadeoutDelayMs = 500;
-constexpr int kStrokeFadeoutDurationMs = 500;
-constexpr int kStrokeScaleDurationMs = 300;
-
-gfx::RectF GetPenTipRect(const gfx::PointF& p) {
-  return gfx::RectF(p.x() - kPenTipWidth / 2, p.y() - kPenTipHeight / 2,
-                    kPenTipWidth, kPenTipHeight);
-}
-
-gfx::Rect GetSegmentDamageRect(const gfx::RectF& r1, const gfx::RectF& r2) {
-  gfx::RectF rect = r1;
-  rect.Union(r2);
-  rect.Inset(-kOutsetForAntialiasing, -kOutsetForAntialiasing);
-  return gfx::ToEnclosingRect(rect);
-}
-
-// A highlighter segment is best imagined as a result of a rectangle
-// being dragged along a straight line, while keeping its orientation.
-// r1 is the start position of the rectangle and r2 is the final position.
-void DrawSegment(gfx::Canvas& canvas,
-                 const gfx::RectF& r1,
-                 const gfx::RectF& r2,
-                 const cc::PaintFlags& flags) {
-  if (r1.x() > r2.x()) {
-    DrawSegment(canvas, r2, r1, flags);
-    return;
-  }
-
-  SkPath path;
-  path.moveTo(r1.x(), r1.y());
-  if (r1.y() < r2.y())
-    path.lineTo(r1.right(), r1.y());
-  else
-    path.lineTo(r2.x(), r2.y());
-  path.lineTo(r2.right(), r2.y());
-  path.lineTo(r2.right(), r2.bottom());
-  if (r1.y() < r2.y())
-    path.lineTo(r2.x(), r2.bottom());
-  else
-    path.lineTo(r1.right(), r1.bottom());
-  path.lineTo(r1.x(), r1.bottom());
-  path.lineTo(r1.x(), r1.y());
-  canvas.DrawPath(path, flags);
-}
-
-}  // namespace
-
-const SkColor HighlighterView::kPenColor =
-    SkColorSetA(kHighlighterColor, kHighlighterOpacity);
-
-const gfx::SizeF HighlighterView::kPenTipSize(kPenTipWidth, kPenTipHeight);
-
-HighlighterView::HighlighterView(aura::Window* root_window)
-    : FastInkView(root_window) {}
-
-HighlighterView::~HighlighterView() {}
-
-void HighlighterView::AddNewPoint(const gfx::PointF& point) {
-  TRACE_EVENT1("ui", "HighlighterView::AddNewPoint", "point", point.ToString());
-
-  if (!points_.empty()) {
-    UpdateDamageRect(GetSegmentDamageRect(GetPenTipRect(points_.back()),
-                                          GetPenTipRect(point)));
-  }
-
-  points_.push_back(point);
-
-  RequestRedraw();
-}
-
-void HighlighterView::Animate(const gfx::PointF& pivot,
-                              AnimationMode animation_mode) {
-  animation_timer_.reset(new base::Timer(
-      FROM_HERE, base::TimeDelta::FromMilliseconds(kStrokeFadeoutDelayMs),
-      base::Bind(&HighlighterView::FadeOut, base::Unretained(this), pivot,
-                 animation_mode),
-      false));
-  animation_timer_->Reset();
-}
-
-void HighlighterView::FadeOut(const gfx::PointF& pivot,
-                              AnimationMode animation_mode) {
-  ui::Layer* layer = GetWidget()->GetLayer();
-
-  {
-    ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
-    settings.SetTransitionDuration(
-        base::TimeDelta::FromMilliseconds(kStrokeFadeoutDurationMs));
-    settings.SetTweenType(gfx::Tween::LINEAR_OUT_SLOW_IN);
-
-    layer->SetOpacity(0);
-  }
-
-  if (animation_mode != AnimationMode::kFadeout) {
-    ui::ScopedLayerAnimationSettings settings(layer->GetAnimator());
-    settings.SetTransitionDuration(
-        base::TimeDelta::FromMilliseconds(kStrokeScaleDurationMs));
-    settings.SetTweenType(gfx::Tween::LINEAR_OUT_SLOW_IN);
-
-    const float scale = animation_mode == AnimationMode::kInflate
-                            ? kStrokeScale
-                            : (1 / kStrokeScale);
-
-    gfx::Transform transform;
-    transform.Translate(pivot.x() * (1 - scale), pivot.y() * (1 - scale));
-    transform.Scale(scale, scale);
-
-    layer->SetTransform(transform);
-  }
-}
-
-void HighlighterView::OnRedraw(gfx::Canvas& canvas,
-                               const gfx::Vector2d& offset) {
-  if (points_.size() < 2)
-    return;
-
-  gfx::Rect clip_rect;
-  if (!canvas.GetClipBounds(&clip_rect))
-    return;
-
-  cc::PaintFlags flags;
-  flags.setStyle(cc::PaintFlags::kFill_Style);
-  flags.setAntiAlias(true);
-  flags.setColor(kPenColor);
-  flags.setBlendMode(SkBlendMode::kSrc);
-
-  for (size_t i = 1; i < points_.size(); ++i) {
-    const gfx::RectF tip1 = GetPenTipRect(points_[i - 1]) - offset;
-    const gfx::RectF tip2 = GetPenTipRect(points_[i]) - offset;
-    // Only draw the segment if it is touching the clip rect.
-    if (clip_rect.Intersects(GetSegmentDamageRect(tip1, tip2)))
-      DrawSegment(canvas, tip1, tip2, flags);
-  }
-}
-
-}  // namespace ash

ash/highlighter/highlighter_view.h

-// Copyright 2017 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.
-
-#ifndef ASH_HIGHLIGHTER_HIGHLIGHTER_VIEW_H_
-#define ASH_HIGHLIGHTER_HIGHLIGHTER_VIEW_H_
-
-#include <vector>
-
-#include "ash/fast_ink/fast_ink_view.h"
-#include "base/time/time.h"
-
-namespace aura {
-class Window;
-}
-
-namespace base {
-class Timer;
-}
-
-namespace gfx {
-class PointF;
-}
-
-namespace ash {
-
-// HighlighterView displays the highlighter palette tool. It draws the
-// highlighter stroke which consists of a series of thick lines connecting
-// touch points.
-class HighlighterView : public FastInkView {
- public:
-  enum class AnimationMode {
-    kFadeout,
-    kInflate,
-    kDeflate,
-  };
-
-  static const SkColor kPenColor;
-  static const gfx::SizeF kPenTipSize;
-
-  explicit HighlighterView(aura::Window* root_window);
-  ~HighlighterView() override;
-
-  const std::vector<gfx::PointF>& points() const { return points_; }
-
-  void AddNewPoint(const gfx::PointF& new_point);
-
-  void Animate(const gfx::PointF& pivot, AnimationMode animation_mode);
-
- private:
-  void OnRedraw(gfx::Canvas& canvas, const gfx::Vector2d& offset) override;
-
-  void FadeOut(const gfx::PointF& pivot, AnimationMode animation_mode);
-
-  std::vector<gfx::PointF> points_;
-  std::unique_ptr<base::Timer> animation_timer_;
-
-  DISALLOW_COPY_AND_ASSIGN(HighlighterView);
-};
-
-}  // namespace ash
-
-#endif  // ASH_HIGHLIGHTER_HIGHLIGHTER_VIEW_H_

ash/shell.cc

@@ -39,7 +39,6 @@
 #include "ash/frame/custom_frame_view_ash.h"
 #include "ash/gpu_support.h"
 #include "ash/high_contrast/high_contrast_controller.h"
-#include "ash/highlighter/highlighter_controller.h"
 #include "ash/host/ash_window_tree_host_init_params.h"
 #include "ash/ime/ime_controller.h"
 #include "ash/keyboard/keyboard_ui.h"
@@ -753,7 +752,6 @@ Shell::~Shell() {
   audio_a11y_controller_.reset();
   laser_pointer_controller_.reset();
   partial_magnification_controller_.reset();
-  highlighter_controller_.reset();
 
   // This also deletes all RootWindows. Note that we invoke Shutdown() on
   // WindowTreeHostManager before resetting |window_tree_host_manager_|, since
@@ -1055,7 +1053,6 @@ void Shell::Init(const ShellInitParams& init_params) {
 
   laser_pointer_controller_.reset(new LaserPointerController());
   partial_magnification_controller_.reset(new PartialMagnificationController());
-  highlighter_controller_.reset(new HighlighterController());
 
   magnification_controller_.reset(MagnificationController::CreateInstance());
   mru_window_tracker_ = base::MakeUnique<MruWindowTracker>();

ash/shell.h

@@ -102,7 +102,6 @@ class FirstRunHelper;
 class FocusCycler;
 class GPUSupport;
 class HighContrastController;
-class HighlighterController;
 class ImeController;
 class ImmersiveContextAsh;
 class ImmersiveHandlerFactoryAsh;
@@ -389,9 +388,6 @@ class ASH_EXPORT Shell : public SessionObserver,
   PartialMagnificationController* partial_magnification_controller() {
     return partial_magnification_controller_.get();
   }
-  HighlighterController* highlighter_controller() {
-    return highlighter_controller_.get();
-  }
   ScreenshotController* screenshot_controller() {
     return screenshot_controller_.get();
   }
@@ -799,7 +795,6 @@ class ASH_EXPORT Shell : public SessionObserver,
   std::unique_ptr<LaserPointerController> laser_pointer_controller_;
   std::unique_ptr<PartialMagnificationController>
       partial_magnification_controller_;
-  std::unique_ptr<HighlighterController> highlighter_controller_;
 
   // The split view controller for Chrome OS in tablet mode.
   std::unique_ptr<SplitViewController> split_view_controller_;

ash/system/palette/test_palette_delegate.cc

@@ -53,8 +53,6 @@ void TestPaletteDelegate::ShowMetalayer(const base::Closure& closed) {
   metalayer_closed_ = closed;
 }
 
-void TestPaletteDelegate::HideMetalayer() {
-  ++hide_metalayer_count_;
-}
+void TestPaletteDelegate::HideMetalayer() {}
 
 }  // namespace ash

ash/system/palette/test_palette_delegate.h

@@ -46,8 +46,6 @@ class TestPaletteDelegate : public PaletteDelegate {
 
   int show_metalayer_count() const { return show_metalayer_count_; }
 
-  int hide_metalayer_count() const { return hide_metalayer_count_; }
-
   base::Closure metalayer_closed() const { return metalayer_closed_; }
 
  private:
@@ -75,7 +73,6 @@ class TestPaletteDelegate : public PaletteDelegate {
   bool should_show_palette_ = false;
   bool is_metalayer_supported_ = false;
   int show_metalayer_count_ = 0;
-  int hide_metalayer_count_ = 0;
   base::Closure metalayer_closed_;
 
   DISALLOW_COPY_AND_ASSIGN(TestPaletteDelegate);

ash/system/palette/tools/metalayer_unittest.cc

@@ -59,26 +59,16 @@ TEST_F(MetalayerToolTest, ViewOnlyCreatedWhenMetalayerIsSupported) {
   tool_->OnViewDestroyed();
 }
 
-// Verifies that enabling/disabling the metalayer tool invokes the delegate.
-TEST_F(MetalayerToolTest, EnablingDisablingMetalayerCallsDelegate) {
-  // Enabling the metalayer tool calls the delegate to show the metalayer.
-  // It should also hide the palette.
+// Verifies that enabling the tool triggers the metalayer in the delegate.
+// Invoking the callback passed to the delegate disables the tool.
+TEST_F(MetalayerToolTest, EnablingMetalayerCallsDelegateAndDisablesTool) {
+  // Showing a metalayer calls the palette delegate to show
+  // the metalayer and hides the palette.
   EXPECT_CALL(*palette_tool_delegate_.get(), HidePalette());
   tool_->OnEnable();
   EXPECT_EQ(1, test_palette_delegate()->show_metalayer_count());
-  EXPECT_EQ(0, test_palette_delegate()->hide_metalayer_count());
   testing::Mock::VerifyAndClearExpectations(palette_tool_delegate_.get());
 
-  // Enabling the metalayer tool calls the delegate to hide the metalayer.
-  tool_->OnDisable();
-  EXPECT_EQ(1, test_palette_delegate()->show_metalayer_count());
-  EXPECT_EQ(1, test_palette_delegate()->hide_metalayer_count());
-  testing::Mock::VerifyAndClearExpectations(palette_tool_delegate_.get());
-}
-
-// Verifies that invoking the callback passed to the delegate disables the tool.
-TEST_F(MetalayerToolTest, MetalayerCallbackDisablesPaletteTool) {
-  tool_->OnEnable();
   // Calling the associated callback (metalayer closed) will disable the tool.
   EXPECT_CALL(*palette_tool_delegate_.get(),
               DisableTool(PaletteToolId::METALAYER));

chrome/browser/chromeos/arc/voice_interaction/arc_voice_interaction_framework_service.cc

@@ -35,6 +35,8 @@
 #include "components/arc/arc_browser_context_keyed_service_factory_base.h"
 #include "components/arc/arc_util.h"
 #include "components/arc/instance_holder.h"
+#include "components/exo/surface.h"
+#include "components/exo/wm_helper.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/window.h"
@@ -79,6 +81,24 @@ void ScreenshotCallback(
   callback.Run(result);
 }
 
+bool IsMetalayerWindow(aura::Window* window) {
+  exo::Surface* surface = exo::Surface::AsSurface(window);
+  return surface != nullptr && surface->IsStylusOnly();
+}
+
+void CollectLayers(LayerSet& layers,
+                   aura::Window* root_window,
+                   base::Callback<bool(aura::Window*)> matcher_func) {
+  if (matcher_func.Run(root_window))
+    layers.insert(root_window->layer());
+
+  aura::Window::Windows children = root_window->children();
+  for (aura::Window::Windows::iterator iter = children.begin();
+       iter != children.end(); ++iter) {
+    CollectLayers(layers, *iter, matcher_func);
+  }
+}
+
 std::unique_ptr<ui::LayerTreeOwner> CreateLayerTreeForSnapshot(
     aura::Window* root_window) {
   LayerSet blocked_layers;
@@ -88,12 +108,7 @@ std::unique_ptr<ui::LayerTreeOwner> CreateLayerTreeForSnapshot(
   }
 
   LayerSet excluded_layers;
-  // Exclude metalayer-related layers. This will also include other layers
-  // under kShellWindowId_OverlayContainer which is fine.
-  aura::Window* overlay_container = ash::Shell::GetContainer(
-      root_window, ash::kShellWindowId_OverlayContainer);
-  if (overlay_container != nullptr)
-    excluded_layers.insert(overlay_container->layer());
+  CollectLayers(excluded_layers, root_window, base::Bind(IsMetalayerWindow));
 
   auto layer_tree_owner = ::wm::RecreateLayersWithClosure(
       root_window, base::BindRepeating(
@@ -222,6 +237,11 @@ void ArcVoiceInteractionFrameworkService::OnInstanceReady() {
   binding_.Bind(mojo::MakeRequest(&host_proxy));
   framework_instance->Init(std::move(host_proxy));
 
+  // Temporary shortcut added to enable the metalayer experiment.
+  ash::Shell::Get()->accelerator_controller()->Register(
+      {ui::Accelerator(ui::VKEY_A, ui::EF_COMMAND_DOWN | ui::EF_SHIFT_DOWN)},
+      this);
+
   if (is_request_pending_) {
     is_request_pending_ = false;
     framework_instance->StartVoiceInteractionSession();
@@ -230,10 +250,43 @@ void ArcVoiceInteractionFrameworkService::OnInstanceReady() {
 
 void ArcVoiceInteractionFrameworkService::OnInstanceClosed() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  ash::Shell::Get()->accelerator_controller()->UnregisterAll(this);
   CallAndResetMetalayerCallback();
   metalayer_enabled_ = false;
 }
 
+bool ArcVoiceInteractionFrameworkService::AcceleratorPressed(
+    const ui::Accelerator& accelerator) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+
+  base::RecordAction(base::UserMetricsAction(
+      "VoiceInteraction.MetalayerStarted.Search_Shift_A"));
+
+  // Temporary, used for debugging.
+  // Does not take into account or update the palette state.
+  // Explicitly call ShowMetalayer() to take into account user interaction
+  // initiations.
+  ShowMetalayer(base::Bind([]() {}));
+  return true;
+}
+
+bool ArcVoiceInteractionFrameworkService::CanHandleAccelerators() const {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  return true;
+}
+
+void ArcVoiceInteractionFrameworkService::OnTouchEvent(ui::TouchEvent* event) {
+  if (event->pointer_details().pointer_type !=
+      ui::EventPointerType::POINTER_TYPE_PEN)
+    return;
+
+  if (event->type() == ui::ET_TOUCH_RELEASED) {
+    // Stylus gesture has just completed. This handler is only active while
+    // the metalayer is on. Looks like a legitimate metalayer action.
+    InitiateUserInteraction();
+  }
+}
+
 void ArcVoiceInteractionFrameworkService::CaptureFocusedWindow(
     const CaptureFocusedWindowCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
@@ -308,6 +361,9 @@ void ArcVoiceInteractionFrameworkService::ShowMetalayer(
     return;
   }
   metalayer_closed_callback_ = closed;
+  // Hanlde all stylus events while the metalayer is on.
+  exo::WMHelper::GetInstance()->AddPreTargetHandler(this);
+  SetMetalayerVisibility(true);
 }
 
 void ArcVoiceInteractionFrameworkService::HideMetalayer() {
@@ -317,6 +373,8 @@ void ArcVoiceInteractionFrameworkService::HideMetalayer() {
     return;
   }
   metalayer_closed_callback_ = base::Closure();
+  exo::WMHelper::GetInstance()->RemovePreTargetHandler(this);
+  SetMetalayerVisibility(false);
 }
 
 void ArcVoiceInteractionFrameworkService::OnArcPlayStoreEnabledChanged(
@@ -342,11 +400,25 @@ void ArcVoiceInteractionFrameworkService::StartVoiceInteractionSetupWizard() {
   framework_instance->StartVoiceInteractionSetupWizard();
 }
 
+void ArcVoiceInteractionFrameworkService::SetMetalayerVisibility(bool visible) {
+  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
+  mojom::VoiceInteractionFrameworkInstance* framework_instance =
+      ARC_GET_INSTANCE_FOR_METHOD(
+          arc_bridge_service_->voice_interaction_framework(),
+          SetMetalayerVisibility);
+  if (!framework_instance) {
+    CallAndResetMetalayerCallback();
+    return;
+  }
+  framework_instance->SetMetalayerVisibility(visible);
+}
+
 void ArcVoiceInteractionFrameworkService::CallAndResetMetalayerCallback() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (metalayer_closed_callback_.is_null())
     return;
   base::ResetAndReturn(&metalayer_closed_callback_).Run();
+  exo::WMHelper::GetInstance()->RemovePreTargetHandler(this);
 }
 
 void ArcVoiceInteractionFrameworkService::SetVoiceInteractionEnabled(

chrome/browser/chromeos/arc/voice_interaction/arc_voice_interaction_framework_service.h

@@ -14,6 +14,8 @@
 #include "components/arc/instance_holder.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "mojo/public/cpp/bindings/binding.h"
+#include "ui/base/accelerators/accelerator.h"
+#include "ui/events/event_handler.h"
 
 class KeyedServiceBaseFactory;
 
@@ -35,6 +37,8 @@ class ArcBridgeService;
 class ArcVoiceInteractionFrameworkService
     : public KeyedService,
       public mojom::VoiceInteractionFrameworkHost,
+      public ui::AcceleratorTarget,
+      public ui::EventHandler,
       public InstanceHolder<mojom::VoiceInteractionFrameworkInstance>::Observer,
       public ArcSessionManager::Observer {
  public:
@@ -54,11 +58,17 @@ class ArcVoiceInteractionFrameworkService
   void OnInstanceReady() override;
   void OnInstanceClosed() override;
 
+  // ui::AcceleratorTarget overrides.
+  bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
+  bool CanHandleAccelerators() const override;
+
+  // ui::EventHandler overrides.
+  void OnTouchEvent(ui::TouchEvent* event) override;
+
   // mojom::VoiceInteractionFrameworkHost overrides.
   void CaptureFocusedWindow(
       const CaptureFocusedWindowCallback& callback) override;
   void CaptureFullscreen(const CaptureFullscreenCallback& callback) override;
-  // TODO(kaznacheev) remove usages of this obsolete method from the container.
   void OnMetalayerClosed() override;
   void SetMetalayerEnabled(bool enabled) override;
   void SetVoiceInteractionRunning(bool running) override;
@@ -104,6 +114,8 @@ class ArcVoiceInteractionFrameworkService
   static const char kArcServiceName[];
 
  private:
+  void SetMetalayerVisibility(bool visible);
+
   void CallAndResetMetalayerCallback();
 
   bool InitiateUserInteraction();

chrome/browser/ui/ash/palette_delegate_chromeos.cc

@@ -5,8 +5,6 @@
 #include "chrome/browser/ui/ash/palette_delegate_chromeos.h"
 
 #include "ash/accelerators/accelerator_controller_delegate_classic.h"
-#include "ash/highlighter/highlighter_controller.h"
-#include "ash/highlighter/highlighter_selection_observer.h"
 #include "ash/screenshot_delegate.h"
 #include "ash/shell.h"
 #include "ash/shell_port_classic.h"
@@ -28,26 +26,36 @@
 
 namespace chromeos {
 
-class VoiceInteractionSelectionObserver
-    : public ash::HighlighterSelectionObserver {
+class VoiceInteractionScreenshotDelegate : public ash::ScreenshotDelegate {
  public:
-  explicit VoiceInteractionSelectionObserver(Profile* profile)
+  explicit VoiceInteractionScreenshotDelegate(Profile* profile)
       : profile_(profile) {}
-  ~VoiceInteractionSelectionObserver() override = default;
+  ~VoiceInteractionScreenshotDelegate() override = default;
 
  private:
-  void HandleSelection(const gfx::Rect& rect) override {
+  void HandleTakeScreenshotForAllRootWindows() override { NOTIMPLEMENTED(); }
+
+  void HandleTakePartialScreenshot(aura::Window* window,
+                                   const gfx::Rect& rect) override {
     auto* framework =
         arc::ArcVoiceInteractionFrameworkService::GetForBrowserContext(
             profile_);
     if (!framework)
       return;
-    framework->StartSessionFromUserInteraction(rect);
+    double device_scale_factor = window->layer()->device_scale_factor();
+    framework->StartSessionFromUserInteraction(
+        gfx::ScaleToEnclosingRect(rect, device_scale_factor));
+  }
+
+  void HandleTakeWindowScreenshot(aura::Window* window) override {
+    NOTIMPLEMENTED();
   }
 
+  bool CanTakeScreenshot() override { return true; }
+
   Profile* const profile_;  // Owned by ProfileManager.
 
-  DISALLOW_COPY_AND_ASSIGN(VoiceInteractionSelectionObserver);
+  DISALLOW_COPY_AND_ASSIGN(VoiceInteractionScreenshotDelegate);
 };
 
 PaletteDelegateChromeOS::PaletteDelegateChromeOS() : weak_factory_(this) {
@@ -166,9 +174,22 @@ void PaletteDelegateChromeOS::TakeScreenshot() {
 
 void PaletteDelegateChromeOS::TakePartialScreenshot(const base::Closure& done) {
   auto* screenshot_controller = ash::Shell::Get()->screenshot_controller();
-  auto* screenshot_delegate = ash::ShellPortClassic::Get()
-                                  ->accelerator_controller_delegate()
-                                  ->screenshot_delegate();
+
+  ash::ScreenshotDelegate* screenshot_delegate;
+  if (IsMetalayerSupported()) {
+    // This is an experimental mode. It will be either taken out or grow
+    // into a separate tool next to "Capture region".
+    if (!voice_interaction_screenshot_delegate_) {
+      voice_interaction_screenshot_delegate_ =
+          base::MakeUnique<VoiceInteractionScreenshotDelegate>(profile_);
+    }
+    screenshot_delegate = voice_interaction_screenshot_delegate_.get();
+  } else {
+    screenshot_delegate = ash::ShellPortClassic::Get()
+                              ->accelerator_controller_delegate()
+                              ->screenshot_delegate();
+  }
+
   screenshot_controller->set_pen_events_only(true);
   screenshot_controller->StartPartialScreenshotSession(
       screenshot_delegate, false /* draw_overlay_immediately */);
@@ -196,13 +217,6 @@ void PaletteDelegateChromeOS::ShowMetalayer(const base::Closure& closed) {
     return;
   }
   service->ShowMetalayer(closed);
-
-  if (!highlighter_selection_observer) {
-    highlighter_selection_observer =
-        base::MakeUnique<VoiceInteractionSelectionObserver>(profile_);
-  }
-  ash::Shell::Get()->highlighter_controller()->EnableHighlighter(
-      highlighter_selection_observer.get());
 }
 
 void PaletteDelegateChromeOS::HideMetalayer() {
@@ -211,8 +225,6 @@ void PaletteDelegateChromeOS::HideMetalayer() {
   if (!service)
     return;
   service->HideMetalayer();
-
-  ash::Shell::Get()->highlighter_controller()->DisableHighlighter();
 }
 
 }  // namespace chromeos

chrome/browser/ui/ash/palette_delegate_chromeos.h

@@ -20,7 +20,7 @@ class PrefChangeRegistrar;
 class Profile;
 
 namespace ash {
-class HighlighterSelectionObserver;
+class ScreenshotDelegate;
 }
 
 namespace chromeos {
@@ -72,8 +72,8 @@ class PaletteDelegateChromeOS
       session_state_observer_;
   content::NotificationRegistrar registrar_;
 
-  std::unique_ptr<ash::HighlighterSelectionObserver>
-      highlighter_selection_observer;
+  std::unique_ptr<ash::ScreenshotDelegate>
+      voice_interaction_screenshot_delegate_;
 
   base::WeakPtrFactory<PaletteDelegateChromeOS> weak_factory_;