UMA data collection for docked windows

ash/wm/dock/docked_window_resizer.cc

 // Copyright 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_resizer.h"
 
 #include "ash/ash_switches.h"
 #include "ash/display/display_controller.h"
 #include "ash/launcher/launcher.h"
 #include "ash/root_window_controller.h"
 #include "ash/screen_ash.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/dock/docked_window_layout_manager.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/magnetism_matcher.h"
 #include "ash/wm/workspace/workspace_window_resizer.h"
 #include "base/command_line.h"
 #include "base/memory/weak_ptr.h"
+#include "base/metrics/histogram.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/window_tree_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/screen.h"
 #include "ui/views/widget/widget.h"
@@ skipping 120 matching lines @@
   return next_window_resizer_->GetTarget();
 }
 
 const gfx::Point& DockedWindowResizer::GetInitialLocation() const {
   return details_.initial_location_in_parent;
 }
 
 DockedWindowResizer::DockedWindowResizer(WindowResizer* next_window_resizer,
                                          const Details& details)
     : details_(details),
+      last_docked_action_(base::Time::Now()),
       next_window_resizer_(next_window_resizer),
       dock_layout_(NULL),
       initial_dock_layout_(NULL),
       did_move_or_resize_(false),
       was_docked_(false),
       is_docked_(false),
       weak_ptr_factory_(this) {
   DCHECK(details_.is_resizable);
   aura::Window* dock_container = Shell::GetContainer(
       details.window->GetRootWindow(),
@@ skipping 81 matching lines @@
         window->parent(), dock_layout_->dragged_bounds());
     if (!bounds.IsEmpty() && bounds.width() != window->bounds().width()) {
       window->SetBounds(bounds);
     }
   }
   // No longer restore to pre-docked bounds if a window has been resized.
   if (is_resized && is_docked_)
     window_state->ClearRestoreBounds();
 
   // Check if the window needs to be docked or returned to workspace.
+  DockedAction action = DOCKED_ACTION_CANCEL;
   aura::Window* dock_container = Shell::GetContainer(
       window->GetRootWindow(),
       kShellWindowId_DockedContainer);
   if ((is_resized || !attached_panel) &&
       is_docked_ != (window->parent() == dock_container)) {
     if (is_docked_) {
       wm::ReparentChildWithTransientChildren(dock_container, window);
+      action = DOCKED_ACTION_DOCK;
     } else if (window->parent()->id() == kShellWindowId_DockedContainer) {
       // Reparent the window back to workspace.
       // We need to be careful to give ParentWindowWithContext a location in
       // the right root window (matching the logic in DragWindowResizer) based
       // on which root window a mouse pointer is in. We want to undock into the
       // right screen near the edge of a multiscreen setup (based on where the
       // mouse is).
       gfx::Rect near_last_location(last_location_, gfx::Size());
       // Reparenting will cause Relayout and possible dock shrinking.
       aura::Window* previous_parent = window->parent();
       aura::client::ParentWindowWithContext(window, window, near_last_location);
       if (window->parent() != previous_parent)
         wm::ReparentTransientChildrenOfChild(window->parent(), window);
+      action = was_docked_ ? DOCKED_ACTION_UNDOCK : DOCKED_ACTION_CANCEL;
     }
+  } else {
+    // Docked state was not changed but still need to record a UMA action.
+    if (is_resized && is_docked_ && was_docked_)
+      action = DOCKED_ACTION_RESIZE;
+    else if (is_docked_ && was_docked_)
+      action = DOCKED_ACTION_REORDER;
+    else if (is_docked_ && !was_docked_)
+      action = DOCKED_ACTION_DOCK;
+    else
+      action = DOCKED_ACTION_CANCEL;

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

As with the time between use below, I don't think this "cancel" operation is a
useful metric. It would be effectively the number of windows dragged but not
docked, which is certainly going to outnumber any of the other values.

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

Done.

   }
+  if (action != DOCKED_ACTION_CANCEL) {
+    base::Time time_now = base::Time::Now();
+    UMA_HISTOGRAM_LONG_TIMES_100("Ash.Dock.TimeBetweenUse",
+                                 time_now - last_docked_action_);

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

Doesn't DockedWindowResizer::FinishDragging get called for the for every window
drag whether it was docked or not? This would make the time between use actually
the time between window drags. I'm not sure we could really learn much from the
time between docked window drag operations anyways.

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

Done.

+    last_docked_action_ = time_now;
+  }
+  UMA_HISTOGRAM_ENUMERATION("Ash.Dock.Actions", action, DOCKED_ACTION_COUNT);
   dock_layout_->FinishDragging();
 
   // If we started the drag in one root window and moved into another root
   // but then canceled the drag we may need to inform the original layout
   // manager that the drag is finished.
   if (initial_dock_layout_ != dock_layout_)
     initial_dock_layout_->FinishDragging();
   is_docked_ = false;
 }
 
 }  // namespace internal
 }  // namespace ash