Adding UMA stats for dragdrop events for both touch and mouse.

ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.cc

 // 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 "ui/views/widget/desktop_aura/desktop_drag_drop_client_aurax11.h"
 
 #include <X11/Xatom.h>
 
 #include "base/event_types.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/histogram.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/base/clipboard/clipboard.h"
 #include "ui/base/dragdrop/drop_target_event.h"
 #include "ui/base/dragdrop/os_exchange_data.h"
 #include "ui/base/dragdrop/os_exchange_data_provider_aurax11.h"
 #include "ui/base/x/selection_utils.h"
 #include "ui/base/x/x11_foreign_window_manager.h"
@@ skipping 388 matching lines @@
       xwindow_(xwindow),
       atom_cache_(xdisplay_, kAtomsToCache),
       current_modifier_state_(ui::EF_NONE),
       target_window_(NULL),
       waiting_on_status_(false),
       status_received_since_enter_(false),
       source_provider_(NULL),
       source_current_window_(None),
       source_state_(SOURCE_STATE_OTHER),
       drag_operation_(0),
+      current_drag_event_source_(ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE),
       negotiated_operation_(ui::DragDropTypes::DRAG_NONE),
       weak_ptr_factory_(this) {
   // Some tests change the DesktopDragDropClientAuraX11 associated with an
   // |xwindow|.
   g_live_client_map.Get()[xwindow] = this;
 
   // Mark that we are aware of drag and drop concepts.
   unsigned long xdnd_version = kMinXdndVersion;
   XChangeProperty(xdisplay_, xwindow_, atom_cache_.GetAtom("XdndAware"),
                   XA_ATOM, 32, PropModeReplace,
@@ skipping 208 matching lines @@
     XDeleteProperty(xdisplay_, xwindow_, xselection.property);
 }
 
 int DesktopDragDropClientAuraX11::StartDragAndDrop(
     const ui::OSExchangeData& data,
     aura::Window* root_window,
     aura::Window* source_window,
     const gfx::Point& root_location,
     int operation,
     ui::DragDropTypes::DragEventSource source) {
+  if (source == ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH) {
+    UMA_HISTOGRAM_COUNTS("DragDrop.Touch.Start", 1);
+  } else if (source == ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE) {
+    UMA_HISTOGRAM_COUNTS("DragDrop.Mouse.Start", 1);
+  }
+
   source_current_window_ = None;
   DCHECK(!g_current_drag_drop_client);
   g_current_drag_drop_client = this;
   waiting_on_status_ = false;
   next_position_message_.reset();
   status_received_since_enter_ = false;
   source_state_ = SOURCE_STATE_OTHER;
   drag_operation_ = operation;
   negotiated_operation_ = ui::DragDropTypes::DRAG_NONE;
+  current_drag_event_source_ = source;
 
   const ui::OSExchangeData::Provider* provider = &data.provider();
   source_provider_ = static_cast<const ui::OSExchangeDataProviderAuraX11*>(
       provider);
 
   source_provider_->TakeOwnershipOfSelection();
 
   std::vector< ::Atom> actions = GetOfferedDragOperations();
   if (!source_provider_->file_contents_name().empty()) {
     actions.push_back(atom_cache_.GetAtom(kXdndActionDirectSave));
@@ skipping 98 matching lines @@
 
   if (source_current_window_ != None) {
     if (waiting_on_status_) {
       if (status_received_since_enter_) {
         // If we are waiting for an XdndStatus message, we need to wait for it
         // to complete.
         source_state_ = SOURCE_STATE_PENDING_DROP;
 
         // Start timer to end the move loop if the target takes too long to send
         // the XdndStatus and XdndFinished messages.
         StartEndMoveLoopTimer();

[mfomitchev, 2015/01/08 23:30:59]

Wouldn't this lead to cancelling the DnD? (meaning we should log a cancel)?

[caelyn, 2015/01/12 22:43:10]

See comment below.

         return;
       }
 
       move_loop_->EndMoveLoop();

[mfomitchev, 2015/01/08 23:30:59]

And this?

[caelyn, 2015/01/12 22:43:10]

See comment below.

       return;
     }
 
     if (negotiated_operation_ != ui::DragDropTypes::DRAG_NONE) {

[mfomitchev, 2015/01/08 23:30:59]

What if the negotiated operation is NONE? Don't we need to log a cancel in that
case as well? Rather than doing it in a bunch of different places, perhaps we
could find a way to do it in EndMoveLoop()?

[caelyn, 2015/01/12 22:43:10]

EndMoveLoop is not always called in circumstances where a cancel event is
occurring and I am not sure it makes sense to track it there.

There is already a DragCancel method (which was previously never called, as far
as codesearch will tell me, and I think it was added purely to conform to
aura::client::DragDropClient), which I have modified to call EndMoveLoop and to
track the cancel stats.

[mfomitchev, 2015/01/13 17:01:25]

DragCancel() is at least called from web_contents_view_aura.cc..

I am wondering what will happen if the move loop ends itself (e.g. I think it
can happen on a key press:
https://code.google.com/p/chromium/codesearch#chromium/src/ui/views/widget/de...).
I am also wondering if DragCancel/EndMoveLoop can be called without DnD being
started.. 

Perhaps we should be logging drop/cancel in OnMoveLoopEnded()? Seems like that
could be a decent catch-all.

I've also noticed methods like OnXdndDrop, OnXdndFinished, etc. Any idea when do
they get called? If you haven't done this already, perhaps build the Linux
version, add a bunch of log statements, and run the binary doing DnD is various
different ways to understand this code better and also validate your changes. If
this is non-trivial to figure out, pkotwicz may be able to explain some of this
to us. I was going to ask him some questions about how this code works myself.

[caelyn, 2015/01/13 23:48:58]

Oops. Should have checked from the virtual method, not the override method.
I think that makes the most sense. I wasn't able to produce a case where it
wasn't called, including ending the drag and drop operation by hitting the
escape key on keyboard, which I wasn't capturing as a cancel event before.
OnXdndDrop either gets called from SendXdndDrop or from  a method in
desktop_window_tree_host_x11.cc	(I am not sure how to produce the later case).
OnXdndFinished gets called from OnXdndDrop or from the same dispatch method in
desktop_window_tree_host_x11.cc	 (again, not sure how to provoke that case).
Both are only ever called from a successful drop operation.
Already done.

I also left the UMA_HISTOGRAM_ENUMERATION in the DragCancel method, just in case
it somehow gets called from web_contents_view_aura.cc.

       // Start timer to end the move loop if the target takes too long to send
       // an XdndFinished message. It is important that StartEndMoveLoopTimer()
       // is called before SendXdndDrop() because SendXdndDrop()
       // sends XdndFinished synchronously if the drop target is a Chrome
       // window.
       StartEndMoveLoopTimer();
 
       // We have negotiated an action with the other end.
       source_state_ = SOURCE_STATE_DROPPED;
+      if (current_drag_event_source_ ==
+          ui::DragDropTypes::DRAG_EVENT_SOURCE_TOUCH) {
+        UMA_HISTOGRAM_COUNTS("DragDrop.Touch.Drop", 1);
+      } else if (current_drag_event_source_ ==
+                 ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE) {
+        UMA_HISTOGRAM_COUNTS("DragDrop.Mouse.Drop", 1);
+      }
       SendXdndDrop(source_current_window_);
       return;
     }
   }
 
   move_loop_->EndMoveLoop();
 }
 
 void DesktopDragDropClientAuraX11::OnMoveLoopEnded() {
   if (source_current_window_ != None) {
@@ skipping 388 matching lines @@
     for (int x = 0; x < in_bitmap->width(); ++x) {
       if (SkColorGetA(in_row[x]) > kMinAlpha)
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace views