UMA data collection for docked windows

ash/wm/dock/docked_window_layout_manager.cc

 // 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.
 
 #include "ash/wm/dock/docked_window_layout_manager.h"
 
 #include "ash/ash_switches.h"
 #include "ash/launcher/launcher.h"
 #include "ash/screen_ash.h"
 #include "ash/shelf/shelf_layout_manager.h"
 #include "ash/shelf/shelf_types.h"
 #include "ash/shelf/shelf_widget.h"
 #include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/coordinate_conversion.h"
 #include "ash/wm/window_animations.h"
 #include "ash/wm/window_properties.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace_controller.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
+#include "base/metrics/histogram.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/aura/client/activation_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/rect.h"
 
@@ skipping 208 matching lines @@
       dragged_window_(NULL),
       is_dragged_window_docked_(false),
       is_dragged_from_dock_(false),
       launcher_(NULL),
       workspace_controller_(workspace_controller),
       in_fullscreen_(workspace_controller_->GetWindowState() ==
           WORKSPACE_WINDOW_STATE_FULL_SCREEN),
       docked_width_(0),
       alignment_(DOCKED_ALIGNMENT_NONE),
       last_active_window_(NULL),
+      previous_docked_windows_(0),
       background_widget_(new DockedBackgroundWidget(dock_container_)) {
   DCHECK(dock_container);
   aura::client::GetActivationClient(Shell::GetPrimaryRootWindow())->
       AddObserver(this);
   Shell::GetInstance()->AddShellObserver(this);
 }
 
 DockedWindowLayoutManager::~DockedWindowLayoutManager() {
   Shutdown();
 }
@@ skipping 196 matching lines @@
   if (IsPopupOrTransient(child))
     return;
   // Dragged windows are stopped being observed by FinishDragging and do not
   // change alignment during the drag. They also cannot be set to be the
   // |last_active_window_|.
   if (child == dragged_window_)
     return;
   // If this is the last window, set alignment and maximize the workspace.
   if (!IsAnyWindowDocked()) {
     alignment_ = DOCKED_ALIGNMENT_NONE;
+    int previous_docked_width = docked_width_;
     docked_width_ = 0;
+    if (docked_width_ != previous_docked_width)
+      UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.Dock.Width", docked_width_, 0, 360, 72);

[flackr, 2013/10/29 21:33:49]

Create a common method for updating and/or tracking new docked width.

[varkha, 2013/10/30 19:21:00]

Done.

   }
   if (last_active_window_ == child)
     last_active_window_ = NULL;
   child->RemoveObserver(this);
   wm::GetWindowState(child)->RemoveObserver(this);
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::CHILD_CHANGED);
 }
 
 void DockedWindowLayoutManager::OnChildWindowVisibilityChanged(
@@ skipping 92 matching lines @@
   // The window property will still be set, but no actual change will occur
   // until OnFullscreenStateChange is called when exiting fullscreen.
   if (in_fullscreen_)
     return;
   if (window_state->IsMinimized()) {
     MinimizeDockedWindow(window_state);
   } else if (window_state->IsMaximizedOrFullscreen()) {
     // Reparenting changes the source bounds for the animation if a window is
     // visible so hide it here and show later when it is already in the desktop.
     UndockWindow(window);
+    UMA_HISTOGRAM_ENUMERATION("Ash.Dock.Actions",
+                              DOCKED_ACTION_MAXIMIZE, DOCKED_ACTION_COUNT);
   } else {
     RestoreDockedWindow(window_state);
   }
 }
 
 /////////////////////////////////////////////////////////////////////////////
 // DockLayoutManager, WindowObserver implementation:
 
 void DockedWindowLayoutManager::OnWindowBoundsChanged(
     aura::Window* window,
@@ skipping 18 matching lines @@
 }
 
 void DockedWindowLayoutManager::OnWindowDestroying(aura::Window* window) {
   if (dragged_window_ == window) {
     FinishDragging();
     DCHECK(!dragged_window_);
     DCHECK (!is_dragged_window_docked_);
   }
   if (window == last_active_window_)
     last_active_window_ = NULL;
+  UMA_HISTOGRAM_ENUMERATION("Ash.Dock.Actions",
+                            DOCKED_ACTION_CLOSE, DOCKED_ACTION_COUNT);
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 // DockLayoutManager, aura::client::ActivationChangeObserver implementation:
 
 void DockedWindowLayoutManager::OnWindowActivated(aura::Window* gained_active,
                                                   aura::Window* lost_active) {
   if (gained_active && IsPopupOrTransient(gained_active))
     return;
@@ skipping 17 matching lines @@
     aura::Window* child) {
   // Minimize any windows that don't fit without overlap.
   const gfx::Rect work_area =
       Shell::GetScreen()->GetDisplayNearestWindow(dock_container_).work_area();
   int available_room = work_area.height() - kMinDockGap;
   if (child)
     available_room -= (GetWindowHeightCloseTo(child, 0) + kMinDockGap);
   // Use a copy of children array because a call to Minimize can change order.
   aura::Window::Windows children(dock_container_->children());
   aura::Window::Windows::const_reverse_iterator iter = children.rbegin();
+  int docked_windows = child ? 1 : 0;
   while (iter != children.rend()) {
     aura::Window* window(*iter++);
     if (window == child || !IsUsedByLayout(window))
       continue;
     int room_needed = GetWindowHeightCloseTo(window, 0) + kMinDockGap;
-    if (available_room > room_needed)
+    if (available_room > room_needed) {
       available_room -= room_needed;
-    else
-      wm::GetWindowState(window)->Minimize();
+      docked_windows++;
+      continue;
+    }
+    wm::GetWindowState(window)->Minimize();
   }
+  if (docked_windows != previous_docked_windows_)
+    UMA_HISTOGRAM_COUNTS_100("Ash.Dock.Items", docked_windows);

[flackr, 2013/10/29 21:33:49]

MaybeMinimizeChildrenExcept is only called from RestoreDockedWindow, i.e. this
seems like the only time you'll be logging the item count is when a docked
window is restored, but not when they are docked / undocked / closed / etc.

[varkha, 2013/10/30 19:21:00]

MaybeMinimizeChildrenExcept is called from FinishDragging so that should get
called in all those cases other than closing a window. And of course if it is
not called from any interaction that could increase the count then it would be a
bug. I reworked it a bit, please see.

+  previous_docked_windows_ = docked_windows;
 }
 
 void DockedWindowLayoutManager::MinimizeDockedWindow(
     wm::WindowState* window_state) {
   DCHECK(!IsPopupOrTransient(window_state->window()));
   window_state->window()->Hide();
   if (window_state->IsActive())
     window_state->Deactivate();
+  UMA_HISTOGRAM_ENUMERATION("Ash.Dock.Actions",
+                            DOCKED_ACTION_MINIMIZE, DOCKED_ACTION_COUNT);
 }
 
 void DockedWindowLayoutManager::RestoreDockedWindow(
     wm::WindowState* window_state) {
   aura::Window* window = window_state->window();
   DCHECK(!IsPopupOrTransient(window));
   // Always place restored window at the top shuffling the other windows down.
   // TODO(varkha): add a separate container for docked windows to keep track
   // of ordering.
   gfx::Display display = Shell::GetScreen()->GetDisplayNearestWindow(
       dock_container_);
   const gfx::Rect work_area = display.work_area();
 
   // Evict the window if it can no longer be docked because of its height.
   if (!CanDockWindow(window, SNAP_NONE)) {
     UndockWindow(window);
+    UMA_HISTOGRAM_ENUMERATION("Ash.Dock.Actions",
+                              DOCKED_ACTION_EVICT, DOCKED_ACTION_COUNT);
     return;
   }
   gfx::Rect bounds(window->bounds());
   bounds.set_y(work_area.y() - bounds.height());
   window->SetBounds(bounds);
   window->Show();
   MaybeMinimizeChildrenExcept(window);
+  UMA_HISTOGRAM_ENUMERATION("Ash.Dock.Actions",
+                            DOCKED_ACTION_RESTORE, DOCKED_ACTION_COUNT);
 }
 
 void DockedWindowLayoutManager::OnDraggedWindowDocked(aura::Window* window) {
   DCHECK(!is_dragged_window_docked_);
   is_dragged_window_docked_ = true;
 
   // If there are no other docked windows update alignment.
   if (!IsAnyWindowDocked())
     alignment_ = DOCKED_ALIGNMENT_NONE;
 }
@@ skipping 136 matching lines @@
 
   // Calculate initial vertical offset and the gap or overlap between windows.
   const int num_windows = visible_windows->size();
   const float delta = kMinDockGap + (float)available_room /
       ((available_room > 0 || num_windows <= 1) ?
           num_windows + 1 : num_windows - 1);
   float y_pos = work_area.y() + ((delta > 0) ? delta : kMinDockGap);
 
   // Docked area is shown only if there is at least one non-dragged visible
   // docked window.
+  int previous_docked_width = docked_width_;
   docked_width_ = ideal_docked_width;
   if (visible_windows->empty() ||
       (visible_windows->size() == 1 &&
           (*visible_windows)[0].window() == dragged_window_)) {
     docked_width_ = 0;
   }
-
+  if (docked_width_ != previous_docked_width)
+    UMA_HISTOGRAM_CUSTOM_COUNTS("Ash.Dock.Width", docked_width_, 0, 360, 72);

[flackr, 2013/10/29 21:33:49]

It might be worth setting a higher max in case we decide to change the limit at
some point. I would use something higher than you expect any screen resolution
to be.

[varkha, 2013/10/30 19:21:00]

Done.

   // Sort windows by their center positions and fan out overlapping
   // windows.
   std::sort(visible_windows->begin(), visible_windows->end(),
             CompareWindowPos(is_dragged_from_dock_ ? dragged_window_ : NULL,
                 delta));
   for (std::vector<WindowWithHeight>::iterator iter = visible_windows->begin();
       iter != visible_windows->end(); ++iter) {
     aura::Window* window = iter->window();
     gfx::Rect bounds = ScreenAsh::ConvertRectToScreen(
         window->parent(), window->GetTargetBounds());
@@ skipping 145 matching lines @@
 void DockedWindowLayoutManager::OnKeyboardBoundsChanging(
     const gfx::Rect& keyboard_bounds) {
   // This bounds change will have caused a change to the Shelf which does not
   // propagate automatically to this class, so manually recalculate bounds.
   Relayout();
   UpdateDockBounds(DockedWindowLayoutManagerObserver::KEYBOARD_BOUNDS_CHANGING);
 }
 
 }  // namespace internal
 }  // namespace ash