UMA data collection for docked windows

ash/wm/dock/docked_window_layout_manager.h

 // Copyright (c) 2013 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_WM_DOCK_DOCKED_WINDOW_LAYOUT_MANAGER_H_
 #define ASH_WM_DOCK_DOCKED_WINDOW_LAYOUT_MANAGER_H_
 
 #include "ash/ash_export.h"
 #include "ash/shelf/shelf_layout_manager_observer.h"
 #include "ash/shell_observer.h"
 #include "ash/wm/dock/dock_types.h"
 #include "ash/wm/dock/docked_window_layout_manager_observer.h"
 #include "ash/wm/window_state_observer.h"
 #include "ash/wm/workspace/snap_types.h"
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/observer_list.h"
+#include "base/time/time.h"
 #include "ui/aura/client/activation_change_observer.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_observer.h"
 #include "ui/gfx/rect.h"
 #include "ui/keyboard/keyboard_controller_observer.h"
 
 namespace aura {
 class Window;
 }
 
 namespace gfx {
 class Point;
 }
 
 namespace views {
 class Widget;
 }
 
 namespace ash {
 class Launcher;
 
 namespace internal {
 class DockedWindowLayoutManagerObserver;
 class DockedWindowResizerTest;
 class ShelfLayoutManager;
 class WorkspaceController;
 
+// User action recorded for use in UMA histograms.
+enum DockedAction {
+  DOCKED_ACTION_NONE,       // Regular drag of undocked window. Not recorded.
+  DOCKED_ACTION_DOCK,       // Dragged and docked a window.
+  DOCKED_ACTION_UNDOCK,     // Dragged and undocked a window.
+  DOCKED_ACTION_RESIZE,     // Resized a docked window.
+  DOCKED_ACTION_REORDER,    // Possibly reordered docked windows.
+  DOCKED_ACTION_EVICT,      // A docked window could not stay docked.
+  DOCKED_ACTION_MAXIMIZE,   // Maximized a docked window.
+  DOCKED_ACTION_MINIMIZE,   // Minimized a docked window.
+  DOCKED_ACTION_RESTORE,    // Restored a docked window that was minimized.
+  DOCKED_ACTION_CLOSE,      // Closed a window while it was docked.
+  DOCKED_ACTION_COUNT,      // Maximum value of this enum for histograms use.
+};
+
+// Event source for the docking user action (when known).
+enum DockedActionSource {
+  DOCKED_ACTION_SOURCE_UNKNOWN,
+  DOCKED_ACTION_SOURCE_MOUSE,
+  DOCKED_ACTION_SOURCE_TOUCH,
+
+  // Maximum value of this enum for histograms use.
+  DOCKED_ACTION_SOURCE_COUNT,
+};
+
 struct WindowWithHeight {
   explicit WindowWithHeight(aura::Window* window) :
     window_(window),
     height_(window->bounds().height()) { }
   aura::Window* window() { return window_; }
   const aura::Window* window() const { return window_; }
   aura::Window* window_;
   int height_;
 };
 
@@ skipping 39 matching lines @@
   void StartDragging(aura::Window* window);
 
   // Called by a DockedWindowResizer when a dragged window is docked.
   void DockDraggedWindow(aura::Window* window);
 
   // Called by a DockedWindowResizer when a dragged window is no longer docked.
   void UndockDraggedWindow();
 
   // Called by a DockedWindowResizer when a window is no longer being dragged.
   // Stops observing the window unless it is a child.
-  void FinishDragging();
+  // Records |action| by |source| in UMA.
+  void FinishDragging(DockedAction action, DockedActionSource source);
 
   ash::Launcher* launcher() { return launcher_; }
   void SetLauncher(ash::Launcher* launcher);
 
   // Calculates if a window is touching the screen edges and returns edge.
   DockedAlignment GetAlignmentOfWindow(const aura::Window* window) const;
 
   // Used to snap docked windows to the side of screen during drag.
   DockedAlignment CalculateAlignment() const;
 
@@ skipping 55 matching lines @@
   static const int kIdealWidth;
 
   // Keep at most kMaxVisibleWindows visible in the dock and minimize the rest
   // (except for |child|).
   void MaybeMinimizeChildrenExcept(aura::Window* child);
 
   // Minimize / restore window and relayout.
   void MinimizeDockedWindow(wm::WindowState* window_state);
   void RestoreDockedWindow(wm::WindowState* window_state);
 
+  // Record user-initiated |action| by |source| in UMA metrics.
+  void RecordUmaAction(DockedAction action, DockedActionSource source);
+
+  // Updates |docked_width_| and UMA histograms.
+  void UpdateDockedWidth(int width);
+
   // Updates docked layout state when a window gets inside the dock.
   void OnDraggedWindowDocked(aura::Window* window);
 
   // Updates docked layout state when a window gets outside the dock.
   void OnDraggedWindowUndocked();
 
   // Returns true if there are any windows currently docked.
   bool IsAnyWindowDocked();
 
   // Called whenever the window layout might change.
@@ skipping 67 matching lines @@
   // Target bounds of a docked window being dragged.
   gfx::Rect dragged_bounds_;
 
   // Side of the screen that the dock is positioned at.
   DockedAlignment alignment_;
 
   // The last active window. Used to maintain stacking order even if no windows
   // are currently focused.
   aura::Window* last_active_window_;
 
+  // Timestamp of the last user-initiated action that changed docked state.
+  // Used in UMA metrics.
+  base::Time last_action_time_;
+
   // Widget used to paint a background for the docked area.
   scoped_ptr<views::Widget> background_widget_;
 
   // Observers of dock bounds changes.
   ObserverList<DockedWindowLayoutManagerObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(DockedWindowLayoutManager);
 };
 
 }  // namespace internal
 }  // namespace ash
 
 #endif  // ASH_WM_DOCK_DOCKED_WINDOW_LAYOUT_MANAGER_H_