Add gesture type value from infobar to permission report

chrome/browser/permissions/permission_queue_controller.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 "chrome/browser/permissions/permission_queue_controller.h"
 
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/content_settings/host_content_settings_map_factory.h"
 #include "chrome/browser/geolocation/geolocation_infobar_delegate_android.h"
 #include "chrome/browser/infobars/infobar_service.h"
@@ skipping 35 matching lines @@
 }
 
 }  // anonymous namespace
 
 class PermissionQueueController::PendingInfobarRequest {
  public:
   PendingInfobarRequest(content::PermissionType type,
                         const PermissionRequestID& id,
                         const GURL& requesting_frame,
                         const GURL& embedder,
+                        bool user_gesture,
                         Profile* profile,
                         const PermissionDecidedCallback& callback);
   ~PendingInfobarRequest();
 
   bool IsForPair(const GURL& requesting_frame,
                  const GURL& embedder) const;
 
   const PermissionRequestID& id() const { return id_; }
   const GURL& requesting_frame() const { return requesting_frame_; }
   bool has_infobar() const { return !!infobar_; }
   infobars::InfoBar* infobar() { return infobar_; }
 
   void RunCallback(ContentSetting content_setting);
   void CreateInfoBar(PermissionQueueController* controller);
 
  private:
   content::PermissionType type_;
   PermissionRequestID id_;
   GURL requesting_frame_;
   GURL embedder_;
+  bool user_gesture_;
   Profile* profile_;
   PermissionDecidedCallback callback_;
   infobars::InfoBar* infobar_;
 
   // Purposefully do not disable copying, as this is stored in STL containers.
 };
 
 PermissionQueueController::PendingInfobarRequest::PendingInfobarRequest(
     content::PermissionType type,
     const PermissionRequestID& id,
     const GURL& requesting_frame,
     const GURL& embedder,
+    bool user_gesture,
     Profile* profile,
     const PermissionDecidedCallback& callback)
     : type_(type),
       id_(id),
       requesting_frame_(requesting_frame),
       embedder_(embedder),
+      user_gesture_(user_gesture),
       profile_(profile),
       callback_(callback),
       infobar_(NULL) {}
 
 PermissionQueueController::PendingInfobarRequest::~PendingInfobarRequest() {
 }
 
 bool PermissionQueueController::PendingInfobarRequest::IsForPair(
     const GURL& requesting_frame,
     const GURL& embedder) const {
   return (requesting_frame_ == requesting_frame) && (embedder_ == embedder);
 }
 
 void PermissionQueueController::PendingInfobarRequest::RunCallback(
     ContentSetting content_setting) {
   callback_.Run(content_setting);
 }
 
 void PermissionQueueController::PendingInfobarRequest::CreateInfoBar(
     PermissionQueueController* controller) {
   // Controller can be Unretained because the lifetime of the infobar
   // is tied to that of the queue controller. Before QueueController
   // is destroyed, all requests will be cancelled and so all delegates
   // will be destroyed.
-  PermissionInfobarDelegate::PermissionSetCallback callback =
-      base::Bind(&PermissionQueueController::OnPermissionSet,
-                 base::Unretained(controller),
-                 id_,
-                 requesting_frame_,
-                 embedder_);
+  PermissionInfobarDelegate::PermissionSetCallback callback = base::Bind(
+      &PermissionQueueController::OnPermissionSet, base::Unretained(controller),
+      id_, requesting_frame_, embedder_, user_gesture_);
   switch (type_) {
     case content::PermissionType::GEOLOCATION:
       infobar_ = GeolocationInfoBarDelegateAndroid::Create(
-          GetInfoBarService(id_), requesting_frame_, profile_, callback);
+          GetInfoBarService(id_), requesting_frame_, user_gesture_, profile_,
+          callback);
       break;
 #if defined(ENABLE_NOTIFICATIONS)
     case content::PermissionType::NOTIFICATIONS:
       infobar_ = NotificationPermissionInfobarDelegate::Create(
-          GetInfoBarService(id_), requesting_frame_, profile_, callback);
+          GetInfoBarService(id_), requesting_frame_, user_gesture_, profile_,
+          callback);
       break;
 #endif  // ENABLE_NOTIFICATIONS
     case content::PermissionType::MIDI_SYSEX:
       infobar_ = MidiPermissionInfoBarDelegateAndroid::Create(
-          GetInfoBarService(id_), requesting_frame_, profile_, callback);
+          GetInfoBarService(id_), requesting_frame_, user_gesture_, profile_,
+          callback);
       break;
     case content::PermissionType::PROTECTED_MEDIA_IDENTIFIER:
       infobar_ = ProtectedMediaIdentifierInfoBarDelegateAndroid::Create(
-          GetInfoBarService(id_), requesting_frame_, profile_, callback);
+          GetInfoBarService(id_), requesting_frame_, user_gesture_, profile_,
+          callback);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 PermissionQueueController::PermissionQueueController(
     Profile* profile,
     content::PermissionType permission_type,
     ContentSettingsType content_settings_type)
     : profile_(profile),
       permission_type_(permission_type),
       content_settings_type_(content_settings_type),
       in_shutdown_(false) {}
 
 PermissionQueueController::~PermissionQueueController() {
   // Cancel all outstanding requests.
   in_shutdown_ = true;
   while (!pending_infobar_requests_.empty())
     CancelInfoBarRequest(pending_infobar_requests_.front().id());
 }
 
 void PermissionQueueController::CreateInfoBarRequest(
     const PermissionRequestID& id,
     const GURL& requesting_frame,
     const GURL& embedder,
+    bool user_gesture,
     const PermissionDecidedCallback& callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   if (requesting_frame.SchemeIs(content::kChromeUIScheme) ||
       embedder.SchemeIs(content::kChromeUIScheme))
     return;
 
-  pending_infobar_requests_.push_back(PendingInfobarRequest(
-      permission_type_, id, requesting_frame, embedder, profile_, callback));
+  pending_infobar_requests_.push_back(
+      PendingInfobarRequest(permission_type_, id, requesting_frame, embedder,
+                            user_gesture, profile_, callback));
   if (!AlreadyShowingInfoBarForTab(id))
     ShowQueuedInfoBarForTab(id);
 }
 
 void PermissionQueueController::CancelInfoBarRequest(
     const PermissionRequestID& id) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   for (PendingInfobarRequests::iterator i(pending_infobar_requests_.begin());
        i != pending_infobar_requests_.end(); ++i) {
     if (id != i->id())
       continue;
 
     InfoBarService* infobar_service = GetInfoBarService(id);
     if (infobar_service && i->has_infobar())
       infobar_service->RemoveInfoBar(i->infobar());
     else
       pending_infobar_requests_.erase(i);
     return;
   }
 }
 
-void PermissionQueueController::OnPermissionSet(
-    const PermissionRequestID& id,
-    const GURL& requesting_frame,
-    const GURL& embedder,
-    bool update_content_setting,
-    bool allowed) {
+void PermissionQueueController::OnPermissionSet(const PermissionRequestID& id,
+                                                const GURL& requesting_frame,
+                                                const GURL& embedder,
+                                                bool user_gesture,
+                                                bool update_content_setting,
+                                                bool allowed) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // TODO(miguelg): move the permission persistence to
   // PermissionContextBase once all the types are moved there.
-  // TODO(stefanocs): Pass the actual |gesture_type| value to PermissionUmaUtil.
+  PermissionRequestGestureType gesture_type =
+      user_gesture ? PermissionRequestGestureType::GESTURE
+                   : PermissionRequestGestureType::NO_GESTURE;
   if (update_content_setting) {
     UpdateContentSetting(requesting_frame, embedder, allowed);
     if (allowed) {
-      PermissionUmaUtil::PermissionGranted(
-          permission_type_, PermissionRequestGestureType::UNKNOWN,
-          requesting_frame, profile_);
+      PermissionUmaUtil::PermissionGranted(permission_type_, gesture_type,
+                                           requesting_frame, profile_);
     } else {
-      PermissionUmaUtil::PermissionDenied(permission_type_,
-                                          PermissionRequestGestureType::UNKNOWN,
+      PermissionUmaUtil::PermissionDenied(permission_type_, gesture_type,
                                           requesting_frame, profile_);
     }
   } else {
-    PermissionUmaUtil::PermissionDismissed(
-        permission_type_, PermissionRequestGestureType::UNKNOWN,
-        requesting_frame, profile_);
+    PermissionUmaUtil::PermissionDismissed(permission_type_, gesture_type,
+                                           requesting_frame, profile_);
   }
 
   // Cancel this request first, then notify listeners.  TODO(pkasting): Why
   // is this order important?
   PendingInfobarRequests requests_to_notify;
   PendingInfobarRequests infobars_to_remove;
   std::vector<PendingInfobarRequests::iterator> pending_requests_to_remove;
   for (PendingInfobarRequests::iterator i = pending_infobar_requests_.begin();
        i != pending_infobar_requests_.end(); ++i) {
     if (!i->IsForPair(requesting_frame, embedder))
@@ skipping 159 matching lines @@
   }
 
   ContentSetting content_setting =
       allowed ? CONTENT_SETTING_ALLOW : CONTENT_SETTING_BLOCK;
 
   HostContentSettingsMapFactory::GetForProfile(profile_)
       ->SetContentSettingDefaultScope(
           requesting_frame.GetOrigin(), embedder.GetOrigin(),
           content_settings_type_, std::string(), content_setting);
 }