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 <map>
+#include <utility>

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

why are these new imports needed?

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

See reasoning from the .h file.

+
 #include "base/event_types.h"
 #include "base/lazy_instance.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/histogram_macros.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 209 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) {
+  UMA_HISTOGRAM_ENUMERATION("DragDrop.Start", source,
+                            ui::DragDropTypes::DRAG_EVENT_SOURCE_COUNT);
+
   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 48 matching lines @@
                                               const ui::LocatedEvent& event) {
   NOTIMPLEMENTED();
 }
 
 void DesktopDragDropClientAuraX11::Drop(aura::Window* target,
                                         const ui::LocatedEvent& event) {
   NOTIMPLEMENTED();
 }
 
 void DesktopDragDropClientAuraX11::DragCancel() {
+  UMA_HISTOGRAM_ENUMERATION("DragDrop.Cancel", current_drag_event_source_,
+                            ui::DragDropTypes::DRAG_EVENT_SOURCE_COUNT);
   move_loop_->EndMoveLoop();
 }
 
 bool DesktopDragDropClientAuraX11::IsDragDropInProgress() {
   return !!g_current_drag_drop_client;
 }
 
 void DesktopDragDropClientAuraX11::OnWindowDestroyed(aura::Window* window) {
   DCHECK_EQ(target_window_, window);
   target_window_ = NULL;
@@ skipping 17 matching lines @@
   repeat_mouse_move_timer_.Stop();
   ProcessMouseMove(screen_point, event_time.InMilliseconds());
 }
 
 void DesktopDragDropClientAuraX11::OnMouseReleased() {
   repeat_mouse_move_timer_.Stop();
 
   if (source_state_ != SOURCE_STATE_OTHER) {
     // The user has previously released the mouse and is clicking in
     // frustration.
-    move_loop_->EndMoveLoop();
+    DragCancel();
     return;
   }
 
   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();
+        DragCancel();
         return;
       }
 
-      move_loop_->EndMoveLoop();
+      DragCancel();
       return;
     }
 
     if (negotiated_operation_ != ui::DragDropTypes::DRAG_NONE) {
       // 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;
+      UMA_HISTOGRAM_ENUMERATION("DragDrop.Drop", current_drag_event_source_,
+                                ui::DragDropTypes::DRAG_EVENT_SOURCE_COUNT);
       SendXdndDrop(source_current_window_);
       return;
+    } else {
+      DragCancel();

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

Unless there is a good reason not to, just let it fall through to
EndMoveLoop()/DragCancel() at the bottom.

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

Done.

+      return;
     }
   }
 
   move_loop_->EndMoveLoop();

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

DragCancel()?

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

Since OnMoveLoopEnded gets called from X11WholeScreenMoveLoop::EndMoveLoop(), I
am reasonably certain that we can safely let this method fall to this point.
(EndMoveLoop is a pure virtual method that is overridden only in
X11WholeScreenMoveLoop and desktop_drag_drop_client_aurax11_unittest.cc)

 }
 
 void DesktopDragDropClientAuraX11::OnMoveLoopEnded() {
   if (source_current_window_ != None) {
     SendXdndLeave(source_current_window_);
     source_current_window_ = None;
   }
   target_current_context_.reset();
   repeat_mouse_move_timer_.Stop();
   end_move_loop_timer_.Stop();
@@ skipping 382 matching lines @@
     for (int x = 0; x < in_bitmap->width(); ++x) {
       if (SkColorGetA(in_row[x]) > kMinAlpha)
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace views