Implement workspace scrubbing

ash/wm/workspace/workspace_cycler.cc

Index: ash/wm/workspace/workspace_cycler.cc
diff --git a/ash/wm/workspace/workspace_cycler.cc b/ash/wm/workspace/workspace_cycler.cc
new file mode 100644
index 0000000000000000000000000000000000000000..d16506c181d4540768ffd323e135558c96c15506
--- /dev/null
+++ b/ash/wm/workspace/workspace_cycler.cc
@@ -0,0 +1,91 @@
+// 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 "ash/wm/workspace/workspace_cycler.h"
+
+#include "ash/shell.h"
+#include "ash/wm/workspace/workspace_manager.h"
+#include "ui/base/events/event.h"
+#include "ui/base/events/event_utils.h"
+
+namespace ash {
+namespace internal {
+
+namespace {
+
+// The required vertical distance to scrub to the next workspace.
+const int kWorkspaceStepSize = 10;
+
+// Returns true is scrubbing is enabled.
+bool IsScrubbingEnabled() {
+  // Scrubbing is disabled if the screen is locked or a modal dialog is open.
+  return !Shell::GetInstance()->IsScreenLocked() &&
+         !Shell::GetInstance()->IsSystemModalWindowOpen();
+}
+
+}  // namespace
+
+WorkspaceCycler::WorkspaceCycler(WorkspaceManager* workspace_manager)
+    : workspace_manager_(workspace_manager),
+      scrubbing_(false),
+      scroll_x_(0),
+      scroll_y_(0) {
+  ash::Shell::GetInstance()->AddPreTargetHandler(this);
+}
+
+WorkspaceCycler::~WorkspaceCycler() {
+  scrubbing_ = false;
+  ash::Shell::GetInstance()->RemovePreTargetHandler(this);
+}
+
+ui::EventResult WorkspaceCycler::OnScrollEvent(ui::ScrollEvent* event) {
+  if (event->finger_count() != 3 ||
+      event->type() != ui::ET_SCROLL) {
+    scrubbing_ = false;
+    return ui::ER_UNHANDLED;
+  }
+
+  if (!IsScrubbingEnabled()) {
+    scrubbing_ = false;
+    return ui::ER_UNHANDLED;
+  }
+
+  if (!scrubbing_) {
+    scrubbing_ = true;
+    scroll_x_ = 0;
+    scroll_y_ = 0;
+  }
+
+  if (ui::IsNaturalScrollEnabled()) {
+    scroll_x_ += event->x_offset();
+    scroll_y_ += event->y_offset();
+  } else {
+    scroll_x_ -= event->x_offset();
+    scroll_y_ -= event->y_offset();
+  }
+
+  if (std::abs(scroll_y_) > kWorkspaceStepSize) {
+    workspace_manager_->CycleToWorkspace(scroll_y_ > 0 ?

[sky, 2012/11/30 01:39:45]

You sure you don't want the logic I outlined in the last patch. Your patch makes
it so you always have to move z-pixels, even right after a switch. That doesn't
seem the greatest to me.

[pkotwicz, 2012/11/30 02:12:48]

I am unsure if I completely understand your comment.
It is true that my CL forces a user to always move z-pixels even after a switch.
In particular, I ignore the fact that a user may have scrolled z+y pixels
causing the workspace switch (I do not take in account (y), the remainder). I do
not implement switching through multiple workspaces as a result of a single
scroll event either.
I can add a TODO to implement this.

Some more background:
I actually had implemented switching through multiple workspaces as the result
of a single scroll event in a previous CL and Sadrul advised me to only switch
through a single workspace per scroll event. In the world of this CL where there
is no/little animation while switching through workspaces, a user would most
likely not know that they have switched through multiple workspaces, making it
confusing.

+        WorkspaceManager::CYCLE_NEXT : WorkspaceManager::CYCLE_PREVIOUS);
+
+    scroll_x_ = 0;
+    scroll_y_ = 0;
+    return ui::ER_HANDLED;
+  }
+
+  if (std::abs(scroll_x_) > kWorkspaceStepSize) {
+    // Update |scroll_x_| and |scroll_y_| such that workspaces are only cycled
+    // through when there recently was a significant amount of vertical movement
+    // as opposed to vertical movement accumulated over a long horizontal three
+    // finger scroll.
+    scroll_x_ = 0;
+    scroll_y_ = 0;
+  }
+
+  // The active workspace was not changed, do not consume the event.
+  return ui::ER_UNHANDLED;
+}
+
+}  // namespace internal
+}  // namespace ash