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

chrome/browser/guestview/webview/webview_guest.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/guestview/webview/webview_guest.h"
 
 #include "base/command_line.h"
 #include "base/strings/stringprintf.h"
 #include "chrome/browser/extensions/api/web_request/web_request_api.h"
 #include "chrome/browser/extensions/extension_renderer_state.h"
@@ skipping 18 matching lines @@
 #include "content/public/common/content_switches.h"
 #include "content/public/common/result_codes.h"
 #include "extensions/common/constants.h"
 #include "net/base/net_errors.h"
 
 #if defined(ENABLE_PLUGINS)
 #include "chrome/browser/guestview/webview/plugin_permission_helper.h"
 #endif
 
 using content::WebContents;
+using content::UserMetricsAction;
 
 namespace {
 
 static std::string TerminationStatusToString(base::TerminationStatus status) {
   switch (status) {
     case base::TERMINATION_STATUS_NORMAL_TERMINATION:
       return "normal";
     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
     case base::TERMINATION_STATUS_STILL_RUNNING:
       return "abnormal";
@@ skipping 90 matching lines @@
     return NULL;
   return guest->AsWebView();
 }
 
 // static
 WebViewGuest* WebViewGuest::FromWebContents(WebContents* contents) {
   GuestView* guest = GuestView::FromWebContents(contents);
   return guest ? guest->AsWebView() : NULL;
 }
 
+// static
+void WebViewGuest::RecordUserInitiatedUMA(const PermissionResponseInfo& info,
+                                          bool allow) {
+  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 (info.permission_type) {
+      case BROWSER_PLUGIN_PERMISSION_TYPE_DOWNLOAD:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionAllow.Download"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_GEOLOCATION:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionAllow.Geolocation"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_MEDIA:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionAllow.Media"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_POINTER_LOCK:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionAllow.PointerLock"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_NEW_WINDOW:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionAllow.NewWindow"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_JAVASCRIPT_DIALOG:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionAllow.JSDialog"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_UNKNOWN:
+        break;
+      default: {
+        WebViewPermissionType webview_permission_type =
+            static_cast<WebViewPermissionType>(info.permission_type);
+        switch (webview_permission_type) {
+          case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN:
+            RecordAction(
+                UserMetricsAction("WebView.Guest.PermissionAllow.PluginLoad"));
+            break;
+          default:
+            break;
+        }
+      }
+    }
+  } else {
+    switch (info.permission_type) {
+      case BROWSER_PLUGIN_PERMISSION_TYPE_DOWNLOAD:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionDeny.Download"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_GEOLOCATION:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionDeny.Geolocation"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_MEDIA:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionDeny.Media"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_POINTER_LOCK:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionDeny.PointerLock"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_NEW_WINDOW:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionDeny.NewWindow"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_JAVASCRIPT_DIALOG:
+        RecordAction(
+            UserMetricsAction("BrowserPlugin.PermissionDeny.JSDialog"));
+        break;
+      case BROWSER_PLUGIN_PERMISSION_TYPE_UNKNOWN:
+        break;
+      default: {
+        WebViewPermissionType webview_permission_type =
+            static_cast<WebViewPermissionType>(info.permission_type);
+        switch (webview_permission_type) {
+          case WEB_VIEW_PERMISSION_TYPE_LOAD_PLUGIN:
+            RecordAction(
+                UserMetricsAction("WebView.Guest.PermissionDeny.PluginLoad"));
+            break;
+          default:
+            break;
+        }
+      }
+    }
+  }
+}
+
 void WebViewGuest::Attach(WebContents* embedder_web_contents,
                           const base::DictionaryValue& args) {
   std::string user_agent_override;
   if (args.GetString(webview::kParameterUserAgentOverride,
                      &user_agent_override)) {
     SetUserAgentOverride(user_agent_override);
   } else {
     SetUserAgentOverride("");
   }
 
@@ skipping 152 matching lines @@
     bool allowed_by_default) {
   // If there are too many pending permission requests then reject this request.
   if (pending_permission_requests_.size() >=
       webview::kMaxOutstandingPermissionRequests) {
     callback.Run(false, std::string());
     return true;
   }
 
   int request_id = next_permission_request_id_++;
   pending_permission_requests_[request_id] =
-      PermissionResponseInfo(callback, allowed_by_default);
+      PermissionResponseInfo(callback, permission_type, allowed_by_default);
   scoped_ptr<base::DictionaryValue> args(request_info.DeepCopy());
   args->SetInteger(webview::kRequestId, request_id);
   switch (permission_type) {
     case BROWSER_PLUGIN_PERMISSION_TYPE_NEW_WINDOW: {
       DispatchEvent(new GuestView::Event(webview::kEventNewWindow,
                                          args.Pass()));
       break;
     }
     case BROWSER_PLUGIN_PERMISSION_TYPE_JAVASCRIPT_DIALOG: {
       chrome::VersionInfo::Channel channel = chrome::VersionInfo::GetChannel();
@@ skipping 67 matching lines @@
   if (request_itr == pending_permission_requests_.end())
     return SET_PERMISSION_INVALID;
 
   const PermissionResponseInfo& info = request_itr->second;
   bool allow = (action == ALLOW) ||
       ((action == DEFAULT) && info.allowed_by_default);
 
   info.callback.Run(allow, user_input);
   pending_permission_requests_.erase(request_itr);
 
+  // Only record user initiated (i.e. non-default) actions.
+  if (action != DEFAULT)
+    RecordUserInitiatedUMA(info, allow);
+
   return allow ? SET_PERMISSION_ALLOWED : SET_PERMISSION_DENIED;
 }
 
 void WebViewGuest::SetUserAgentOverride(
     const std::string& user_agent_override) {
   is_overriding_user_agent_ = !user_agent_override.empty();
   if (is_overriding_user_agent_) {
-    content::RecordAction(content::UserMetricsAction(
-                              "WebView.Guest.OverrideUA"));
+    content::RecordAction(UserMetricsAction("WebView.Guest.OverrideUA"));
   }
   guest_web_contents()->SetUserAgentOverride(user_agent_override);
 }
 
 void WebViewGuest::Stop() {
   guest_web_contents()->Stop();
 }
 
 void WebViewGuest::Terminate() {
-  content::RecordAction(content::UserMetricsAction("WebView.Guest.Terminate"));
+  content::RecordAction(UserMetricsAction("WebView.Guest.Terminate"));
   base::ProcessHandle process_handle =
       guest_web_contents()->GetRenderProcessHost()->GetHandle();
   if (process_handle)
     base::KillProcess(process_handle, content::RESULT_CODE_KILLED, false);
 }
 
 bool WebViewGuest::ClearData(const base::Time remove_since,
                              uint32 removal_mask,
                              const base::Closure& callback) {
+  content::RecordAction(UserMetricsAction("WebView.Guest.ClearData"));
   content::StoragePartition* partition =
       content::BrowserContext::GetStoragePartition(
           web_contents()->GetBrowserContext(),
           web_contents()->GetSiteInstance());
 
   if (!partition)
     return false;
 
   partition->ClearData(
       removal_mask,
@@ skipping 134 matching lines @@
                                const gfx::Size& new_size) {
   scoped_ptr<DictionaryValue> args(new DictionaryValue());
   args->SetInteger(webview::kOldHeight, old_size.height());
   args->SetInteger(webview::kOldWidth, old_size.width());
   args->SetInteger(webview::kNewHeight, new_size.height());
   args->SetInteger(webview::kNewWidth, new_size.width());
   DispatchEvent(new GuestView::Event(webview::kEventSizeChanged, args.Pass()));
 }
 
 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo()
-    : allowed_by_default(false) {
+    : permission_type(BROWSER_PLUGIN_PERMISSION_TYPE_UNKNOWN),
+      allowed_by_default(false) {
 }
 
 WebViewGuest::PermissionResponseInfo::PermissionResponseInfo(
     const PermissionResponseCallback& callback,
+    BrowserPluginPermissionType permission_type,
     bool allowed_by_default)
     : callback(callback),
+      permission_type(permission_type),
       allowed_by_default(allowed_by_default) {
 }
 
 WebViewGuest::PermissionResponseInfo::~PermissionResponseInfo() {
 }