Add metrics for usage of permission features from iframes in blink

third_party/WebKit/Source/modules/notifications/Notification.cpp

 /*
  * Copyright (C) 2013 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 66 matching lines @@
         exceptionState.throwTypeError("Illegal constructor.");
         return nullptr;
     }
 
     if (!options.actions().isEmpty()) {
         exceptionState.throwTypeError("Actions are only supported for persistent notifications shown using ServiceWorkerRegistration.showNotification().");
         return nullptr;
     }
 
     String insecureOriginMessage;
-    UseCounter::Feature feature = context->isSecureContext(insecureOriginMessage)
-        ? UseCounter::NotificationSecureOrigin
-        : UseCounter::NotificationInsecureOrigin;
-
-    UseCounter::count(context, feature);
+    if (context->isSecureContext(insecureOriginMessage)) {
+        UseCounter::count(context, UseCounter::NotificationSecureOrigin);
+        if (context->isDocument())
+            UseCounter::countCrossOriginIframe(*toDocument(context),  UseCounter::NotificationAPISecureOriginIframe);
+    } else {
+        UseCounter::count(context, UseCounter::NotificationInsecureOrigin);
+        if (context->isDocument())
+            UseCounter::countCrossOriginIframe(*toDocument(context),  UseCounter::NotificationAPIInsecureOriginIframe);
+    }
 
     WebNotificationData data = createWebNotificationData(context, title, options, exceptionState);
     if (exceptionState.hadException())
         return nullptr;
 
     Notification* notification = new Notification(context, data);
     notification->scheduleShow();
     notification->suspendIfNeeded();
 
     return notification;
@@ skipping 211 matching lines @@
 {
     SecurityOrigin* origin = context->securityOrigin();
     ASSERT(origin);
 
     return notificationManager()->checkPermission(WebSecurityOrigin(origin));
 }
 
 ScriptPromise Notification::requestPermission(ScriptState* scriptState, NotificationPermissionCallback* deprecatedCallback)
 {
     ExecutionContext* context = scriptState->executionContext();
+
+    // Measure usage in cross-origin iframes.

[mlamouri (slow - plz ping), 2016/01/19 17:54:48]

Why do we need to know that? If we want to know usage, requestPermission() is
going to add noise.

[raymes, 2016/01/20 00:13:12]

I tried to make what we're counting consistent across permissions. The question
is how do we define "usage". Is it:
1) when a site tries to use an API even if the user doesn't give permission. 
2) only when a site actually uses an API after it has been granted.

I chatted to Ben briefly about this - both seem interesting and I'd like to add
stats for both, but this CL was intended to count (1).

Notifications is an odd case. With other permission APIs, the permission request
is a part of the API flow. e.g. when you call geolocation, the the user will get
prompted with the call. Same with midi - you have to call requestMIDIAccess to
get access to the API, which will trigger a prompt. So with those APIs, we're
really currently counting API usage regardless of whether the user gives
permission.

With notifications, requesting the permission is a separate function. The site
could try to request the permission, but the user could deny it, so they would
never get to calling "new Notification" (which is what the above stat in this
file is counting). So if we didn't have this here, we would really only be
counting (2).

Does this make sense? I'm open to other suggestions.

+    if (context->isDocument()) {
+        String insecureOriginMessage;
+        if (context->isSecureContext(insecureOriginMessage)) {
+            UseCounter::countCrossOriginIframe(*toDocument(context), UseCounter::NotificationAPISecureOriginIframe);
+        } else {
+            UseCounter::countCrossOriginIframe(*toDocument(context), UseCounter::NotificationAPIInsecureOriginIframe);
+        }
+    }
+
     if (NotificationPermissionClient* permissionClient = NotificationPermissionClient::from(context))
         return permissionClient->requestPermission(scriptState, deprecatedCallback);
 
     // The context has been detached. Return a promise that will never settle.
     ASSERT(context->activeDOMObjectsAreStopped());
     return ScriptPromise();
 }
 
 size_t Notification::maxActions()
 {
@@ skipping 30 matching lines @@
 }
 
 DEFINE_TRACE(Notification)
 {
     visitor->trace(m_asyncRunner);
     RefCountedGarbageCollectedEventTargetWithInlineData<Notification>::trace(visitor);
     ActiveDOMObject::trace(visitor);
 }
 
 } // namespace blink