Add UMA for <webview> APIs: a. ClearData, b. when Permission request is allowed.

content/browser/browser_plugin/browser_plugin_guest.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 "content/browser/browser_plugin/browser_plugin_guest.h"
 
 #include <algorithm>
 
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
@@ skipping 34 matching lines @@
 #include "net/url_request/url_request.h"
 #include "third_party/WebKit/public/web/WebCursorInfo.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/surface/transport_dib.h"
 #include "webkit/common/resource_type.h"
 
 #if defined(OS_MACOSX)
 #include "content/browser/browser_plugin/browser_plugin_popup_menu_helper_mac.h"
 #endif
 
+namespace {
+enum UmaType {
+  UMA_TYPE_DOWNLOAD,
+  UMA_TYPE_GEOLOCATION,
+  UMA_TYPE_MEDIA,
+  UMA_TYPE_POINTER_LOCK,
+  UMA_TYPE_NEW_WINDOW,
+  UMA_TYPE_JAVASCRIPT_DIALOG,
+};
+}  // namespace
+
 namespace content {
 
 // static
 BrowserPluginHostFactory* BrowserPluginGuest::factory_ = NULL;
 
 // Parent class for the various types of permission requests, each of which
 // should be able to handle the response to their permission request.
 class BrowserPluginGuest::PermissionRequest :
     public base::RefCounted<BrowserPluginGuest::PermissionRequest> {
  public:
-  virtual void Respond(bool should_allow, const std::string& user_input) = 0;
+  virtual void Respond(bool should_allow,
+                       const std::string& user_input,
+                       bool user_initiated) = 0;
   virtual bool AllowedByDefault() const {
       return false;
   }
+
  protected:
   PermissionRequest() {
     RecordAction(UserMetricsAction("BrowserPlugin.Guest.PermissionRequest"));
   }
   virtual ~PermissionRequest() {}
+
+  // Only record user initiated (i.e. non-default) actions.
+  void MaybeRecordUserMetrics(UmaType uma_type,
+                              bool allow,
+                              bool user_initiated) const {
+    if (!user_initiated)
+      return;
+
+    if (allow) {
+      // Note that |allow| == true means the embedder explicitly allowed the
+      // request. For some requests they might still fail. An example of such
+      // scenario would be: an embedder allows geolocation request but doesn't
+      // have geolocation access on its own.
+      switch (uma_type) {
+        case UMA_TYPE_DOWNLOAD:
+          RecordAction(UserMetricsAction(
+                           "BrowserPlugin.Guest.PermissionAllow.Download"));

[Fady Samuel, 2013/11/13 15:54:05]

All these strings are really similar. Can't you simply use something like this?
StringPrintf("BrowserPlugin.Guest.PermissionAllow.%s",
PermissionTypeToString(permission))?

[lazyboy, 2013/11/13 17:35:33]

As discussed offline and after talking to sadrul@, these need to be literals.

+          break;
+        case UMA_TYPE_GEOLOCATION:
+          RecordAction(UserMetricsAction(
+                           "BrowserPlugin.Guest.PermissionAllow.Geolocation"));
+          break;
+        case UMA_TYPE_MEDIA:
+          RecordAction(UserMetricsAction(
+                           "BrowserPlugin.Guest.PermissionAllow.Media"));
+          break;
+        case UMA_TYPE_POINTER_LOCK:
+          RecordAction(UserMetricsAction(
+                           "BrowserPlugin.Guest.PermissionAllow.PointerLock"));
+          break;
+        case UMA_TYPE_NEW_WINDOW:
+          RecordAction(UserMetricsAction(
+                           "BrowserPlugin.Guest.PermissionAllow.NewWindow"));
+          break;
+        case UMA_TYPE_JAVASCRIPT_DIALOG:
+          RecordAction(
+              UserMetricsAction(
+                  "BrowserPlugin.Guest.PermissionAllow.JavaScriptDialog"));
+          break;
+      }
+    } else {
+      switch (uma_type) {
+        case UMA_TYPE_DOWNLOAD:
+          RecordAction(UserMetricsAction(
+                           "BrowserPlugin.Guest.PermissionDeny.Download"));
+          break;
+        case UMA_TYPE_GEOLOCATION:
+          RecordAction(UserMetricsAction(
+                           "BrowserPlugin.Guest.PermissionDeny.Geolocation"));
+          break;
+        case UMA_TYPE_MEDIA:
+          RecordAction(UserMetricsAction(
+                           "BrowserPlugin.Guest.PermissionDeny.Media"));
+          break;
+        case UMA_TYPE_POINTER_LOCK:
+          RecordAction(UserMetricsAction(
+                           "BrowserPlugin.Guest.PermissionDeny.PointerLock"));
+          break;
+        case UMA_TYPE_NEW_WINDOW:
+          RecordAction(UserMetricsAction(
+                           "BrowserPlugin.Guest.PermissionDeny.NewWindow"));
+          break;
+        case UMA_TYPE_JAVASCRIPT_DIALOG:
+          RecordAction(
+              UserMetricsAction(
+                  "BrowserPlugin.Guest.PermissionDeny.JavaScriptDialog"));
+          break;
+      }
+    }
+  }
+
   // Friend RefCounted so that the dtor can be non-public.
   friend class base::RefCounted<BrowserPluginGuest::PermissionRequest>;
 };
 
 class BrowserPluginGuest::DownloadRequest : public PermissionRequest {
  public:
   explicit DownloadRequest(base::Callback<void(bool)> callback)
       : callback_(callback) {
     RecordAction(
         UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.Download"));
   }
   virtual void Respond(bool should_allow,
-                       const std::string& user_input) OVERRIDE {
+                       const std::string& user_input,
+                       bool user_initiated) OVERRIDE {
     callback_.Run(should_allow);
+    MaybeRecordUserMetrics(UMA_TYPE_DOWNLOAD, should_allow, user_initiated);
   }
 
  private:
   virtual ~DownloadRequest() {}
   base::Callback<void(bool)> callback_;
 };
 
 class BrowserPluginGuest::GeolocationRequest : public PermissionRequest {
  public:
   GeolocationRequest(GeolocationCallback callback,
                      int bridge_id,
                      base::WeakPtrFactory<BrowserPluginGuest>* weak_ptr_factory)
                      : callback_(callback),
                        bridge_id_(bridge_id),
                        weak_ptr_factory_(weak_ptr_factory) {
     RecordAction(
         UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.Geolocation"));
   }
 
   virtual void Respond(bool should_allow,
-                       const std::string& user_input) OVERRIDE {
+                       const std::string& user_input,
+                       bool user_initiated) OVERRIDE {
     base::WeakPtr<BrowserPluginGuest> guest(weak_ptr_factory_->GetWeakPtr());
 
+    MaybeRecordUserMetrics(UMA_TYPE_GEOLOCATION, should_allow, user_initiated);
     WebContents* web_contents = guest->embedder_web_contents();
     if (should_allow && web_contents) {
       // If renderer side embedder decides to allow gelocation, we need to check
       // if the app/embedder itself has geolocation access.
       BrowserContext* browser_context = web_contents->GetBrowserContext();
       if (browser_context) {
         GeolocationPermissionContext* geolocation_context =
             browser_context->GetGeolocationPermissionContext();
         if (geolocation_context) {
           base::Callback<void(bool)> geolocation_callback = base::Bind(
@@ skipping 31 matching lines @@
                const MediaResponseCallback& callback,
                BrowserPluginGuest* guest)
                : request_(request),
                  callback_(callback),
                  guest_(guest) {
     RecordAction(
         UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.Media"));
   }
 
   virtual void Respond(bool should_allow,
-                       const std::string& user_input) OVERRIDE {
+                       const std::string& user_input,
+                       bool user_initiated) OVERRIDE {
     WebContentsImpl* web_contents = guest_->embedder_web_contents();
     if (should_allow && web_contents) {
       // Re-route the request to the embedder's WebContents; the guest gets the
       // permission this way.
       web_contents->RequestMediaAccessPermission(request_, callback_);
     } else {
       // Deny the request.
       callback_.Run(MediaStreamDevices(), scoped_ptr<MediaStreamUI>());
     }
+    MaybeRecordUserMetrics(UMA_TYPE_MEDIA, should_allow, user_initiated);
   }
 
  private:
   virtual ~MediaRequest() {}
   MediaStreamRequest request_;
   MediaResponseCallback callback_;
   BrowserPluginGuest* guest_;
 };
 
 class BrowserPluginGuest::NewWindowRequest : public PermissionRequest {
  public:
   NewWindowRequest(int instance_id, BrowserPluginGuest* guest)
       : instance_id_(instance_id),
         guest_(guest) {
     RecordAction(
         UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.NewWindow"));
   }
 
   virtual void Respond(bool should_allow,
-                       const std::string& user_input) OVERRIDE {
+                       const std::string& user_input,
+                       bool user_initiated) OVERRIDE {
     int embedder_render_process_id =
         guest_->embedder_web_contents()->GetRenderProcessHost()->GetID();
     BrowserPluginGuest* guest =
         guest_->GetWebContents()->GetBrowserPluginGuestManager()->
             GetGuestByInstanceID(instance_id_, embedder_render_process_id);
     if (!guest) {
       LOG(INFO) << "Guest not found. Instance ID: " << instance_id_;
       return;
     }
 
+    MaybeRecordUserMetrics(UMA_TYPE_NEW_WINDOW, should_allow, user_initiated);
     // If we do not destroy the guest then we allow the new window.
     if (!should_allow)
       guest->Destroy();
   }
 
  private:
   virtual ~NewWindowRequest() {}
   int instance_id_;
   BrowserPluginGuest* guest_;
 };
 
 class BrowserPluginGuest::JavaScriptDialogRequest : public PermissionRequest {
  public:
   JavaScriptDialogRequest(const DialogClosedCallback& callback)
       : callback_(callback) {
     RecordAction(
         UserMetricsAction(
             "BrowserPlugin.Guest.PermissionRequest.JavaScriptDialog"));
   }
 
   virtual void Respond(bool should_allow,
-                       const std::string& user_input) OVERRIDE {
+                       const std::string& user_input,
+                       bool user_initiated) OVERRIDE {
     callback_.Run(should_allow, UTF8ToUTF16(user_input));
+    MaybeRecordUserMetrics(UMA_TYPE_JAVASCRIPT_DIALOG, should_allow,
+                           user_initiated);
   }
 
  private:
   virtual ~JavaScriptDialogRequest() {}
   DialogClosedCallback callback_;
 };
 
 class BrowserPluginGuest::PointerLockRequest : public PermissionRequest {
  public:
   PointerLockRequest(BrowserPluginGuest* guest)
       : guest_(guest) {
     RecordAction(
         UserMetricsAction("BrowserPlugin.Guest.PermissionRequest.PointerLock"));
   }
 
   virtual void Respond(bool should_allow,
-                       const std::string& user_input) OVERRIDE {
+                       const std::string& user_input,
+                       bool user_initiated) OVERRIDE {
     guest_->SendMessageToEmbedder(
         new BrowserPluginMsg_SetMouseLock(guest_->instance_id(), should_allow));
+    MaybeRecordUserMetrics(UMA_TYPE_POINTER_LOCK, should_allow, user_initiated);
   }
 
  private:
   virtual ~PointerLockRequest() {}
   BrowserPluginGuest* guest_;
 };
 
 namespace {
 std::string WindowOpenDispositionToString(
   WindowOpenDisposition window_open_disposition) {
@@ skipping 148 matching lines @@
   if (delegate_ && delegate_->IsOverridingUserAgent()) {
     load_url_params.override_user_agent =
         NavigationController::UA_OVERRIDE_TRUE;
   }
   web_contents->GetController().LoadURLWithParams(load_url_params);
 }
 
 void BrowserPluginGuest::RespondToPermissionRequest(
     int request_id,
     bool should_allow,
-    const std::string& user_input) {
+    const std::string& user_input,
+    bool user_initiated) {
   RequestMap::iterator request_itr = permission_request_map_.find(request_id);
   if (request_itr == permission_request_map_.end()) {
     LOG(INFO) << "Not a valid request ID.";
     return;
   }
-  request_itr->second->Respond(should_allow, user_input);
+  request_itr->second->Respond(should_allow, user_input, user_initiated);
   permission_request_map_.erase(request_itr);
 }
 
 int BrowserPluginGuest::RequestPermission(
     BrowserPluginPermissionType permission_type,
     scoped_refptr<BrowserPluginGuest::PermissionRequest> request,
     const base::DictionaryValue& request_info) {
   if (!delegate_) {
-    request->Respond(false, "");
+    request->Respond(false, "", false);
     return browser_plugin::kInvalidPermissionRequestID;
   }
 
   int request_id = ++next_permission_request_id_;
   permission_request_map_[request_id] = request;
 
   BrowserPluginGuestDelegate::PermissionResponseCallback callback =
       base::Bind(&BrowserPluginGuest::RespondToPermissionRequest,
                   AsWeakPtr(),
                   request_id);
   // If BrowserPluginGuestDelegate hasn't handled the permission then we simply
-  // reject it immediately.
+  // perform the default action (which is one of allow or reject) immediately.
   if (!delegate_->RequestPermission(
       permission_type, request_info, callback, request->AllowedByDefault())) {
-    callback.Run(request->AllowedByDefault(), "");
+    callback.Run(request->AllowedByDefault(), "", false);
     return browser_plugin::kInvalidPermissionRequestID;
   }
 
   return request_id;
 }
 
 BrowserPluginGuest* BrowserPluginGuest::CreateNewGuestWindow(
     const OpenURLParams& params) {
   BrowserPluginGuestManager* guest_manager =
       GetWebContents()->GetBrowserPluginGuestManager();
@@ skipping 1278 matching lines @@
   request_info.Set(browser_plugin::kRequestMethod,
                    base::Value::CreateStringValue(request_method));
   request_info.Set(browser_plugin::kURL, base::Value::CreateStringValue(url));
 
   RequestPermission(BROWSER_PLUGIN_PERMISSION_TYPE_DOWNLOAD,
                     new DownloadRequest(callback),
                     request_info);
 }
 
 }  // namespace content