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_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 173 matching lines @@
                                 target_window_location_,
                                 target_window_root_location_,
                                 target_current_context_->GetDragOperation());
       if (target_current_context_->source_client()) {
         event.set_flags(target_current_context_->source_client()
                             ->current_modifier_state());
       } else {
         event.set_flags(XGetModifiers());
       }
 
       drag_operation = delegate->OnPerformDrop(event);

[pkotwicz, 2015/01/14 18:31:30]

If you put a histogram here, you would be able to count how often people drag
something into Chrome in total (from a different app & from within Chrome)

I am unsure how useful such a histogram would be. I am not sure if it is
possible to determine whether the drag occurred as a result of mouse or touch.

[caelyn, 2015/01/14 20:00:26]

The real question is whether we can do the same thing on Windows. Do you happen
to know off the top of your head if we can detect drag drop events, which
originate from outside of chrome, successfully dropping something in chrome?

[pkotwicz, 2015/01/14 20:39:55]

I think that DesktopDropTargetWin::OnDrop() gets called upon a successful drop
regardless of whether the source of the drag is Chrome.

     }
 
     target_window_->RemoveObserver(this);
     target_window_ = NULL;
   }
 
   XEvent xev;
   xev.xclient.type = ClientMessage;
   xev.xclient.message_type = atom_cache_.GetAtom("XdndFinished");
   xev.xclient.format = 32;
@@ skipping 15 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;

[pkotwicz, 2015/01/14 18:31:30]

Chrome for Desktop Linux does not support initiating drag and drop via touch at
all. We would need to change X11WholeScreenMoveLoop::DispatchEvent() and find
out whether we need to block events while a touch drag is in progress.

[caelyn, 2015/01/14 20:00:26]

I know that chrome on linux does not support touch events; but I thought I'd add
support for them anyway since the added complexity is very small and it saves
having ui::DragDropTypes::DRAG_EVENT_SOURCE_MOUSE duplicated three times
(currently DragDrop.Start uses source; but if I switched to using a constant for
the other two, I would switch it as well).  

I don't have strong feelings on it, since, right now, adding back support for
touch events if they do start being supported is really small. If you feel the
added complexity isn't worth it, I'll take it out.

[pkotwicz, 2015/01/14 20:39:55]

Once you move all of the histograms to this method you would be able to remove
|current_drag_event_source_| so I am ok with passing |source| to
UMA_HISTOGRAM_ENUMERATION().

[caelyn, 2015/01/21 16:29:53]

Done.

 
   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 22 matching lines @@
   // whether it is alive after the drag ends.
   base::WeakPtr<DesktopDragDropClientAuraX11> alive(
       weak_ptr_factory_.GetWeakPtr());
 
   // Windows has a specific method, DoDragDrop(), which performs the entire
   // drag. We have to emulate this, so we spin off a nested runloop which will
   // track all cursor movement and reroute events to a specific handler.
   move_loop_->RunMoveLoop(
       source_window,
       cursor_manager_->GetInitializedCursor(ui::kCursorGrabbing));
 

[pkotwicz, 2015/01/14 18:31:30]

Can you move the histogram code for whether a drag & drop operation initiated by
Chrome succeeded here?

[caelyn, 2015/01/14 20:00:26]

Acknowledged. - My tests show moving it here has the same behaviour as the
previous location. Change coming in the next patch.

   if (alive) {
     drag_widget_.reset();
 
     source_provider_ = NULL;
     g_current_drag_drop_client = NULL;
     drag_operation_ = 0;
     XDeleteProperty(xdisplay_, xwindow_, atom_cache_.GetAtom("XdndActionList"));
     XDeleteProperty(xdisplay_, xwindow_, atom_cache_.GetAtom(kXdndDirectSave0));
 
     return negotiated_operation_;
   }
   return ui::DragDropTypes::DRAG_NONE;
 }
 
 void DesktopDragDropClientAuraX11::DragUpdate(aura::Window* target,
                                               const ui::LocatedEvent& event) {
   NOTIMPLEMENTED();
 }
 
 void DesktopDragDropClientAuraX11::Drop(aura::Window* target,
                                         const ui::LocatedEvent& event) {
   NOTIMPLEMENTED();
 }
 
 void DesktopDragDropClientAuraX11::DragCancel() {
+  // EndMoveLoop will call DesktopDragDropClientAuraX11::OnMoveLoopEnded and

[mfomitchev, 2015/01/14 17:03:41]

IMHO this is not really worth explaining in a comment here.

[caelyn, 2015/01/21 16:29:53]

Done.

+  // record a DragDrop.Cancel event in UMA
   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 57 matching lines @@
       source_state_ = SOURCE_STATE_DROPPED;
       SendXdndDrop(source_current_window_);
       return;
     }
   }
 
   move_loop_->EndMoveLoop();
 }
 
 void DesktopDragDropClientAuraX11::OnMoveLoopEnded() {
+  if (negotiated_operation_ == ui::DragDropTypes::DRAG_NONE) {
+    UMA_HISTOGRAM_ENUMERATION("DragDrop.Cancel", current_drag_event_source_,
+                              ui::DragDropTypes::DRAG_EVENT_SOURCE_COUNT);
+  } else {
+    UMA_HISTOGRAM_ENUMERATION("DragDrop.Drop", current_drag_event_source_,
+                              ui::DragDropTypes::DRAG_EVENT_SOURCE_COUNT);
+  }
   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();
 }
 
 scoped_ptr<X11MoveLoop> DesktopDragDropClientAuraX11::CreateMoveLoop(
@@ skipping 379 matching lines @@
     for (int x = 0; x < in_bitmap->width(); ++x) {
       if (SkColorGetA(in_row[x]) > kMinAlpha)
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace views