[counters] add use count for the "override mistake"

Adds 2 counts to see how often this occurs on the web, both the throwing
version (strict mode), and the no-op sloppy mode case, to help determine
if the proposal at https://github.com/tc39/ecma262/pull/1307 is web
compatible.

This is the V8 side of required changes.
The Chromium-side CL: https://crrev.com/c/1280618

BUG=v8:8175
R=littledan@chromium.org, cbruni@chromium.org, jkummerow@chromium.org, yangguo@chromium.org

Cq-Include-Trybots: luci.chromium.try:linux_chromium_rel_ng
Change-Id: Id12336c2e566093bb554b6d4624c9301fbc4a0f7
Reviewed-on: https://chromium-review.googlesource.com/c/1255549
Commit-Queue: Caitlin Potter <caitp@igalia.com>
Reviewed-by: Jakob Kummerow <jkummerow@chromium.org>
Reviewed-by: Adam Klein <adamk@chromium.org>
Cr-Commit-Position: refs/heads/master@{#56706}

include/v8.h

@@ -7358,6 +7358,8 @@ class V8_EXPORT Isolate {
     kDateToLocaleString = 66,
     kDateToLocaleDateString = 67,
     kDateToLocaleTimeString = 68,
+    kAttemptOverrideReadOnlyOnPrototypeSloppy = 69,
+    kAttemptOverrideReadOnlyOnPrototypeStrict = 70,
 
     // If you add new values here, you'll also need to update Chromium's:
     // web_feature.mojom, UseCounterCallback.cpp, and enums.xml. V8 changes to

src/objects.cc

@@ -5275,6 +5275,15 @@ Maybe<bool> Object::CannotCreateProperty(Isolate* isolate,
 Maybe<bool> Object::WriteToReadOnlyProperty(LookupIterator* it,
                                             Handle<Object> value,
                                             ShouldThrow should_throw) {
+  if (it->IsFound() && !it->HolderIsReceiver()) {
+    // "Override mistake" attempted, record a use count to track this per
+    // v8:8175
+    v8::Isolate::UseCounterFeature feature =
+        should_throw == kThrowOnError
+            ? v8::Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict
+            : v8::Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy;
+    it->isolate()->CountUsage(feature);
+  }
   return WriteToReadOnlyProperty(it->isolate(), it->GetReceiver(),
                                  it->GetName(), value, should_throw);
 }

test/cctest/test-usecounters.cc

@@ -81,6 +81,89 @@ TEST(AtomicsWakeAndAtomicsNotify) {
   CHECK_EQ(1, use_counts[v8::Isolate::kAtomicsNotify]);
 }
 
+TEST(OverrideReadOnlyPropertyOnPrototype) {
+  v8::Isolate* isolate = CcTest::isolate();
+  v8::HandleScope scope(isolate);
+  LocalContext env;
+  int use_counts[v8::Isolate::kUseCounterFeatureCount] = {};
+  global_use_counts = use_counts;
+  CcTest::isolate()->SetUseCounterCallback(MockUseCounterCallback);
+  using Isolate = v8::Isolate;
+
+  // Initial setup
+  CompileRun(
+      "Object.defineProperty(Object.prototype, 'readonly', "
+      "{ readonly: true, value: 'readonly', configurable: false });");
+  CHECK_EQ(0, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy]);
+  CHECK_EQ(0, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict]);
+
+  // StoreIC Sloppy
+  CompileRun(
+      "function sloppy() { let sloppy = {}; sloppy.readonly = 'override'; }"
+      "sloppy();");
+  CHECK_EQ(1, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy]);
+  CHECK_EQ(0, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict]);
+  use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy] = 0;
+  use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict] = 0;
+
+  // StoreIC Sloppy (one-shot)
+  CompileRun("let sloppyob = {}; sloppyob.readonly = 'override';");
+  CHECK_EQ(1, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy]);
+  CHECK_EQ(0, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict]);
+  use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy] = 0;
+  use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict] = 0;
+
+  // StoreIC Strict
+  {
+    v8::TryCatch try_catch(isolate);
+    CompileRun(
+        "function strict() {"
+        "    'use strict'; let strict = {}; strict.readonly = 'override';"
+        "}"
+        "strict();");
+    CHECK_EQ(0, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy]);
+    CHECK_EQ(1, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict]);
+    CHECK(try_catch.HasCaught());
+  }
+  use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy] = 0;
+  use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict] = 0;
+
+  // StoreIC Strict (one-shot)
+  {
+    v8::TryCatch try_catch(isolate);
+    CompileRun(
+        "'use strict';"
+        "let strictob = {}; strictob.readonly = 'override';");
+    CHECK_EQ(0, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy]);
+    CHECK_EQ(1, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict]);
+    CHECK(try_catch.HasCaught());
+  }
+  use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy] = 0;
+  use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict] = 0;
+
+  // KeyedStoreIC Sloppy
+  CompileRun(
+      "function sloppy2() { let sloppy = {}; sloppy['readonly'] = 'override'; }"
+      "sloppy2();");
+  CHECK_EQ(1, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy]);
+  CHECK_EQ(0, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict]);
+  use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy] = 0;
+  use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict] = 0;
+
+  // KeyedStoreIC Strict
+  {
+    v8::TryCatch try_catch(isolate);
+    CompileRun(
+        "function strict2() {"
+        "    'use strict'; let strict = {}; strict['readonly'] = 'override';"
+        "}"
+        "strict2();");
+    CHECK_EQ(0, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeSloppy]);
+    CHECK_EQ(1, use_counts[Isolate::kAttemptOverrideReadOnlyOnPrototypeStrict]);
+    CHECK(try_catch.HasCaught());
+  }
+}
+
 }  // namespace test_usecounters
 }  // namespace internal
 }  // namespace v8