Log site engagement scores for permission actions

chrome/browser/permissions/permission_request_manager.cc

 // Copyright 2014 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_request_manager.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/feature_list.h"
@@ skipping 12 matching lines @@
 namespace {
 
 class CancelledRequest : public PermissionRequest {
  public:
   explicit CancelledRequest(PermissionRequest* cancelled)
       : icon_(cancelled->GetIconId()),
 #if defined(OS_ANDROID)
         message_(cancelled->GetMessageText()),
 #endif
         message_fragment_(cancelled->GetMessageTextFragment()),
-        origin_(cancelled->GetOrigin()) {
+        origin_(cancelled->GetOrigin()),
+        request_type_(cancelled->GetPermissionRequestType()) {
   }
   ~CancelledRequest() override {}
 
   IconId GetIconId() const override { return icon_; }
 #if defined(OS_ANDROID)
   base::string16 GetMessageText() const override { return message_; }
 #endif
   base::string16 GetMessageTextFragment() const override {
     return message_fragment_;
   }
   GURL GetOrigin() const override { return origin_; }
 
   // These are all no-ops since the placeholder is non-forwarding.
   void PermissionGranted() override {}
   void PermissionDenied() override {}
   void Cancelled() override {}
 
   void RequestFinished() override { delete this; }
 
+  PermissionRequestType GetPermissionRequestType() const override {
+    return request_type_;
+  }
+
  private:
   IconId icon_;
 #if defined(OS_ANDROID)
   base::string16 message_;
 #endif
   base::string16 message_fragment_;
   GURL origin_;
+  PermissionRequestType request_type_;
 };
 
 bool IsMessageTextEqual(PermissionRequest* a,
                         PermissionRequest* b) {
   if (a == b)
     return true;
   if (a->GetMessageTextFragment() == b->GetMessageTextFragment() &&
       a->GetOrigin() == b->GetOrigin()) {
     return true;
   }
@@ skipping 44 matching lines @@
       persist_(true),
       auto_response_for_test_(NONE),
       weak_factory_(this) {
 #if defined(OS_ANDROID)
   view_ = view_factory_.Run(web_contents);
   view_->SetDelegate(this);
 #endif
 }
 
 PermissionRequestManager::~PermissionRequestManager() {
+  if (!requests_.empty())
+    PermissionUmaUtil::PermissionPromptIgnored(requests_, web_contents());

[raymes, 2017/07/06 05:03:15]

I think by this stage the requests may be empty.

[Timothy Loh, 2017/07/19 06:03:43]

Moved to CleanUpRequests

+
   if (view_ != NULL)
     view_->SetDelegate(NULL);
 
   for (PermissionRequest* request : requests_)
     request->RequestFinished();
   for (PermissionRequest* request : queued_requests_)
     request->RequestFinished();
   for (const auto& entry : duplicate_requests_)
     entry.second->RequestFinished();
 }
@@ skipping 59 matching lines @@
   std::vector<PermissionRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin(); requests_iter != requests_.end();
        requests_iter++) {
     if (*requests_iter != request)
       continue;
 
     // We can simply erase the current entry in the request table if we aren't
     // showing the dialog, or if we are showing it and it can accept the update.
     bool can_erase = !view_ || view_->CanAcceptRequestUpdate();
     if (can_erase) {
+      // Grouped (mic+camera) requests are currently never cancelled.
+      DCHECK_EQ(static_cast<size_t>(1), requests_.size());
+      PermissionUmaUtil::PermissionPromptIgnored(requests_, web_contents());
+
       RequestFinishedIncludingDuplicates(*requests_iter);
       requests_.erase(requests_iter);
 
       if (view_) {
         view_->Hide();
         // Will redraw the bubble if it is being shown.
         DequeueRequestsAndShowBubble();

[Timothy Loh, 2017/06/22 08:02:20]

I think this results in us counting ignores for queued prompts that the user
never sees if the PermissionService is cancelling the requests sequentially.

       }
       return;
     }
 
     // Cancel the existing request and replace it with a dummy.
     PermissionRequest* cancelled_request =
         new CancelledRequest(*requests_iter);
     RequestFinishedIncludingDuplicates(*requests_iter);
     *requests_iter = cancelled_request;
     return;
@@ skipping 112 matching lines @@
 
 const std::vector<PermissionRequest*>& PermissionRequestManager::Requests() {
   return requests_;
 }
 
 void PermissionRequestManager::TogglePersist(bool new_value) {
   persist_ = new_value;
 }
 
 void PermissionRequestManager::Accept() {
-  PermissionUmaUtil::PermissionPromptAccepted(requests_);
+  PermissionUmaUtil::PermissionPromptAccepted(requests_, web_contents());
 
   std::vector<PermissionRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin(); requests_iter != requests_.end();
        requests_iter++) {
     PermissionGrantedIncludingDuplicates(*requests_iter);
   }
   FinalizeBubble();
 }
 
 void PermissionRequestManager::Deny() {
-  PermissionUmaUtil::PermissionPromptDenied(requests_);
+  PermissionUmaUtil::PermissionPromptDenied(requests_, web_contents());
 
   std::vector<PermissionRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     PermissionDeniedIncludingDuplicates(*requests_iter);
   }
   FinalizeBubble();
 }
 
 void PermissionRequestManager::Closing() {
+  PermissionUmaUtil::PermissionPromptDismissed(requests_, web_contents());
+
   std::vector<PermissionRequest*>::iterator requests_iter;
   for (requests_iter = requests_.begin();
        requests_iter != requests_.end();
        requests_iter++) {
     CancelledIncludingDuplicates(*requests_iter);
   }
   FinalizeBubble();
 }
 
 void PermissionRequestManager::ScheduleShowBubble() {
@@ skipping 151 matching lines @@
     case DENY_ALL:
       Deny();
       break;
     case DISMISS:
       Closing();
       break;
     case NONE:
       NOTREACHED();
   }
 }