Count cross-origin property access.

third_party/WebKit/Source/bindings/core/v8/BindingSecurity.cpp

 /*
  * Copyright (C) 2009 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 22 matching lines @@
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/V8BindingForCore.h"
 #include "bindings/core/v8/V8Location.h"
 #include "bindings/core/v8/V8Window.h"
 #include "core/dom/Document.h"
 #include "core/frame/DOMWindow.h"
 #include "core/frame/LocalDOMWindow.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/Location.h"
 #include "core/frame/Settings.h"
+#include "core/frame/UseCounter.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/workers/MainThreadWorkletGlobalScope.h"
 #include "platform/bindings/WrapperCreationSecurityCheck.h"
 #include "platform/weborigin/SecurityOrigin.h"
 
 namespace blink {
 
 namespace {
 
 bool CanAccessWindowInternal(const LocalDOMWindow* accessing_window,
@@ skipping 73 matching lines @@
     ExceptionState& exception_state) {
   DCHECK(target);
 
   // TODO(https://crbug.com/723057): This is intended to match the legacy
   // behavior of when access checks revolved around Frame pointers rather than
   // DOMWindow pointers. This prevents web-visible behavior changes, since the
   // previous implementation had to follow the back pointer to the Frame, and
   // would have to early return when it was null.
   if (!target->GetFrame())
     return false;
+  bool can_access = CanAccessWindow(accessing_window, target, exception_state);
 
-  return CanAccessWindow(accessing_window, target, exception_state);
+  if (!can_access) {
+    UseCounter::Count(accessing_window->GetFrame(),
+                      UseCounter::kCrossOriginPropertyAccess);
+    if (target->opener() == accessing_window) {
+      UseCounter::Count(accessing_window->GetFrame(),
+                        UseCounter::kCrossOriginPropertyAccessFromOpener);
+    }
+  }
+
+  return can_access;
 }
 
 bool BindingSecurity::ShouldAllowAccessTo(
     const LocalDOMWindow* accessing_window,
     const DOMWindow* target,
     ErrorReportOption reporting_option) {
   DCHECK(target);
 
   // TODO(https://crbug.com/723057): This is intended to match the legacy
   // behavior of when access checks revolved around Frame pointers rather than
   // DOMWindow pointers. This prevents web-visible behavior changes, since the
   // previous implementation had to follow the back pointer to the Frame, and
   // would have to early return when it was null.
   if (!target->GetFrame())
     return false;
 
-  return CanAccessWindow(accessing_window, target, reporting_option);
+  bool can_access = CanAccessWindow(accessing_window, target, reporting_option);
+
+  if (!can_access) {
+    UseCounter::Count(accessing_window->GetFrame(),
+                      UseCounter::kCrossOriginPropertyAccess);
+    if (target->opener() == accessing_window) {
+      UseCounter::Count(accessing_window->GetFrame(),
+                        UseCounter::kCrossOriginPropertyAccessFromOpener);
+    }
+  }
+
+  return can_access;
 }
 
 bool BindingSecurity::ShouldAllowAccessTo(
     const LocalDOMWindow* accessing_window,
     const Location* target,
     ExceptionState& exception_state) {
   DCHECK(target);
 
   // TODO(https://crbug.com/723057): This is intended to match the legacy
   // behavior of when access checks revolved around Frame pointers rather than
   // DOMWindow pointers. This prevents web-visible behavior changes, since the
   // previous implementation had to follow the back pointer to the Frame, and
   // would have to early return when it was null.
   if (!target->DomWindow()->GetFrame())
     return false;
 
-  return CanAccessWindow(accessing_window, target->DomWindow(),
-                         exception_state);
+  bool can_access =
+      CanAccessWindow(accessing_window, target->DomWindow(), exception_state);
+
+  if (!can_access) {
+    UseCounter::Count(accessing_window->GetFrame(),
+                      UseCounter::kCrossOriginPropertyAccess);
+    if (target->DomWindow()->opener() == accessing_window) {
+      UseCounter::Count(accessing_window->GetFrame(),
+                        UseCounter::kCrossOriginPropertyAccessFromOpener);
+    }
+  }
+
+  return can_access;
 }
 
 bool BindingSecurity::ShouldAllowAccessTo(
     const LocalDOMWindow* accessing_window,
     const Location* target,
     ErrorReportOption reporting_option) {
   DCHECK(target);
 
   // TODO(https://crbug.com/723057): This is intended to match the legacy
   // behavior of when access checks revolved around Frame pointers rather than
   // DOMWindow pointers. This prevents web-visible behavior changes, since the
   // previous implementation had to follow the back pointer to the Frame, and
   // would have to early return when it was null.
   if (!target->DomWindow()->GetFrame())
     return false;
 
-  return CanAccessWindow(accessing_window, target->DomWindow(),
-                         reporting_option);
+  bool can_access =
+      CanAccessWindow(accessing_window, target->DomWindow(), reporting_option);
+
+  if (!can_access) {
+    UseCounter::Count(accessing_window->GetFrame(),
+                      UseCounter::kCrossOriginPropertyAccess);
+    if (target->DomWindow()->opener() == accessing_window) {
+      UseCounter::Count(accessing_window->GetFrame(),
+                        UseCounter::kCrossOriginPropertyAccessFromOpener);
+    }
+  }
+
+  return can_access;
 }
 
 bool BindingSecurity::ShouldAllowAccessTo(
     const LocalDOMWindow* accessing_window,
     const Node* target,
     ExceptionState& exception_state) {
   if (!target)
     return false;
   return CanAccessWindow(accessing_window, target->GetDocument().domWindow(),
                          exception_state);
@@ skipping 141 matching lines @@
   // TODO(dcheng): Add ContextType, interface name, and property name as
   // arguments, so the generated exception can be more descriptive.
   ExceptionState exception_state(isolate, ExceptionState::kUnknownContext,
                                  nullptr, nullptr);
   exception_state.ThrowSecurityError(
       target->SanitizedCrossDomainAccessErrorMessage(CurrentDOMWindow(isolate)),
       target->CrossDomainAccessErrorMessage(CurrentDOMWindow(isolate)));
 }
 
 }  // namespace blink