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 13 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 122 matching lines @@
     if (*requests_iter != request)
       continue;
 
     // We can simply erase the current entry in the request table if we aren't
     // showing the dialog (because we switched tabs with an active prompt), or
     // if we are showing it and it can accept the update.
     if (!view_ || view_->CanAcceptRequestUpdate()) {
       // TODO(timloh): We should fix this at some point.
       // Grouped (mic+camera) requests are currently never cancelled.
       DCHECK_EQ(static_cast<size_t>(1), requests_.size());
+      PermissionUmaUtil::PermissionPromptIgnored(requests_, web_contents());
 
       if (view_)
         DeleteBubble();
 
       RequestFinishedIncludingDuplicates(*requests_iter);
       requests_.erase(requests_iter);
 
       DequeueRequestsAndShowBubble();
       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;
   }

[raymes, 2017/07/20 03:37:13]

Since this should only be called with a single request_ right now I wonder if we
can simplify this whole loop to just be:

if (request_[0] == *request) 
  FinalizeBubble();

(we would need to make FinalizeBubble handle the case when the view isn't there
but I think that would be ok)

The benefit then is that FinalizeBubble is always called when a permission
request that displayed a bubble is finished (the bubble might be hiding because
of tab switching, but conceptually it's still there). This means that we can
pass an enum value to FinalizeBubble(): accepted,denied,ignored,dismissed from
the various callsites and make the metric logic much clearer.

We could also then remove CancelledRequest and friends.

Even if we do eventually want this to work with mic/camera, I think it would be
reasonable behavior to cancel both requests if either one of them was cancelled.

WDYT?

[Timothy Loh, 2017/07/20 04:59:54]

Done, but I left CancelledRequest in (if CanAcceptRequestUpdate returns false,
we want to leave the prompt alone).

 
   // Since |request| wasn't found in queued_requests_ or
   // requests_ it must have been marked as a duplicate. We can't search
   // duplicate_requests_ by value, so instead use GetExistingRequest to find the
   // key (request it was duped against), and iterate through duplicates of that.
   PermissionRequest* existing_request = GetExistingRequest(request);
   auto range = duplicate_requests_.equal_range(existing_request);
   for (auto it = range.first; it != range.second; ++it) {
     if (request == it->second) {
       it->second->RequestFinished();
@@ skipping 51 matching lines @@
 }
 
 void PermissionRequestManager::DidFinishNavigation(
     content::NavigationHandle* navigation_handle) {
   if (!navigation_handle->IsInMainFrame() ||
       !navigation_handle->HasCommitted() ||
       navigation_handle->IsSameDocument()) {
     return;
   }
 
   CleanUpRequests();

[raymes, 2017/07/20 03:37:13]

nit: could we rename this to something that indicates that outstanding requests
should be ignored. I'd just be worried that we would accidentally call this in
another situation and then the metrics would be wrong

[Timothy Loh, 2017/07/20 04:59:54]

Ack, will do this in a separate patch. I want to call it IgnorePendingRequests
and update comments that say 'pending' to say 'queued' instead.

   main_frame_has_fully_loaded_ = false;
 }
 
 void PermissionRequestManager::DocumentOnLoadCompletedInMainFrame() {
   main_frame_has_fully_loaded_ = true;
   // This is scheduled because while all calls to the browser have been
   // issued at DOMContentLoaded, they may be bouncing around in scheduled
   // callbacks finding the UI thread still. This makes sure we allow those
   // scheduled calls to AddRequest to complete before we show the page-load
   // permissions bubble.
@@ skipping 19 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() {
 #if defined(OS_MACOSX)
   // Mac calls this whenever you press Esc.
   if (!view_)
     return;
 #endif
+
+  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 68 matching lines @@
 
 void PermissionRequestManager::CleanUpRequests() {
   std::deque<PermissionRequest*>::iterator requests_iter;
   for (requests_iter = queued_requests_.begin();
        requests_iter != queued_requests_.end();
        requests_iter++) {
     RequestFinishedIncludingDuplicates(*requests_iter);
   }
   queued_requests_.clear();
 
-  if (view_)
+  if (view_) {
+    PermissionUmaUtil::PermissionPromptIgnored(requests_, web_contents());
     FinalizeBubble();
+  }
 }
 
 PermissionRequest* PermissionRequestManager::GetExistingRequest(
     PermissionRequest* request) {
   for (PermissionRequest* existing_request : requests_)
     if (IsMessageTextEqual(existing_request, request))
       return existing_request;
   for (PermissionRequest* existing_request : queued_requests_)
     if (IsMessageTextEqual(existing_request, request))
       return existing_request;
@@ skipping 71 matching lines @@
     case DENY_ALL:
       Deny();
       break;
     case DISMISS:
       Closing();
       break;
     case NONE:
       NOTREACHED();
   }
 }