Worker: Avoid sending IPC messages for features already counted

third_party/WebKit/Source/core/workers/ThreadedWorkletTest.cpp

 // Copyright 2016 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 "core/dom/TaskRunnerHelper.h"
 #include "core/inspector/ConsoleMessageStorage.h"
 #include "core/testing/DummyPageHolder.h"
 #include "core/workers/ThreadedWorkletGlobalScope.h"
 #include "core/workers/ThreadedWorkletMessagingProxy.h"
 #include "core/workers/ThreadedWorkletObjectProxy.h"
 #include "core/workers/WorkerInspectorProxy.h"
 #include "core/workers/WorkerThread.h"
 #include "core/workers/WorkerThreadStartupData.h"
 #include "core/workers/WorkerThreadTestHelper.h"
 #include "core/workers/WorkletThreadHolder.h"
 #include "platform/CrossThreadFunctional.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace blink {
 
+class ThreadedWorkletObjectProxyForTest final
+    : public ThreadedWorkletObjectProxy {
+ public:
+  ThreadedWorkletObjectProxyForTest(
+      const WeakPtr<ThreadedWorkletMessagingProxy>& messaging_proxy_weak_ptr,
+      ParentFrameTaskRunners* parent_frame_task_runners)
+      : ThreadedWorkletObjectProxy(messaging_proxy_weak_ptr,
+                                   parent_frame_task_runners),
+        reported_features_(UseCounter::kNumberOfFeatures) {}
+
+ protected:
+  void CountFeature(UseCounter::Feature feature) override {
+    // Any feature should be reported only one time.
+    EXPECT_FALSE(reported_features_.QuickGet(feature));
+    reported_features_.QuickSet(feature);
+    ThreadedWorkletObjectProxy::CountFeature(feature);
+  }
+
+  void CountDeprecation(UseCounter::Feature feature) final {
+    // Any feature should be reported only one time.
+    EXPECT_FALSE(reported_features_.QuickGet(feature));
+    reported_features_.QuickSet(feature);
+    ThreadedWorkletObjectProxy::CountDeprecation(feature);
+  }
+
+ private:
+  BitVector reported_features_;
+};
+
 class ThreadedWorkletThreadForTest : public WorkerThread {
  public:
   ThreadedWorkletThreadForTest(
       WorkerLoaderProxyProvider* worker_loader_proxy_provider,
       WorkerReportingProxy& worker_reporting_proxy)
       : WorkerThread(WorkerLoaderProxy::Create(worker_loader_proxy_provider),
                      worker_reporting_proxy) {}
-  ~ThreadedWorkletThreadForTest() override{};
+  ~ThreadedWorkletThreadForTest() override {}
 
   WorkerBackingThread& GetWorkerBackingThread() override {
     auto worklet_thread_holder =
         WorkletThreadHolder<ThreadedWorkletThreadForTest>::GetInstance();
     DCHECK(worklet_thread_holder);
     return *worklet_thread_holder->GetThread();
   }
 
   void ClearWorkerBackingThread() override {}
 
@@ skipping 24 matching lines @@
     EXPECT_TRUE(IsCurrentThread());
     GlobalScope()->CountFeature(feature);
     GetParentFrameTaskRunners()
         ->Get(TaskType::kUnspecedTimer)
         ->PostTask(BLINK_FROM_HERE, CrossThreadBind(&testing::ExitRunLoop));
   }
 
   // Emulates deprecated API use on ThreadedWorkletGlobalScope.
   void CountDeprecation(UseCounter::Feature feature) {
     EXPECT_TRUE(IsCurrentThread());
-    EXPECT_EQ(0u, GetConsoleMessageStorage()->size());
     GlobalScope()->CountDeprecation(feature);
 
     // countDeprecation() should add a warning message.
     EXPECT_EQ(1u, GetConsoleMessageStorage()->size());
     String console_message = GetConsoleMessageStorage()->at(0)->Message();
     EXPECT_TRUE(console_message.Contains("deprecated"));
 
     GetParentFrameTaskRunners()
         ->Get(TaskType::kUnspecedTimer)
         ->PostTask(BLINK_FROM_HERE, CrossThreadBind(&testing::ExitRunLoop));
   }
 };
 
 class ThreadedWorkletMessagingProxyForTest
     : public ThreadedWorkletMessagingProxy {
  public:
   ThreadedWorkletMessagingProxyForTest(ExecutionContext* execution_context)
       : ThreadedWorkletMessagingProxy(execution_context) {
+    worklet_object_proxy_ = WTF::MakeUnique<ThreadedWorkletObjectProxyForTest>(
+        weak_ptr_factory_.CreateWeakPtr(), GetParentFrameTaskRunners());
     worker_loader_proxy_provider_ =
         WTF::MakeUnique<WorkerLoaderProxyProvider>();
     worker_thread_ = WTF::MakeUnique<ThreadedWorkletThreadForTest>(
         worker_loader_proxy_provider_.get(), WorkletObjectProxy());
     ThreadedWorkletThreadForTest::EnsureSharedBackingThread();
   }
 
   ~ThreadedWorkletMessagingProxyForTest() override {
     worker_thread_->GetWorkerLoaderProxy()->DetachProvider(
         worker_loader_proxy_provider_.get());
@@ skipping 59 matching lines @@
   std::unique_ptr<DummyPageHolder> page_;
   std::unique_ptr<ThreadedWorkletMessagingProxyForTest> messaging_proxy_;
 };
 
 TEST_F(ThreadedWorkletTest, UseCounter) {
   MessagingProxy()->Start();
 
   // This feature is randomly selected.
   const UseCounter::Feature kFeature1 = UseCounter::Feature::kRequestFileSystem;
 
-  // API use on the DedicatedWorkerGlobalScope should be recorded in UseCounter
+  // API use on the ThreadedWorkletGlobalScope should be recorded in UseCounter
   // on the Document.
   EXPECT_FALSE(UseCounter::IsCounted(GetDocument(), kFeature1));
   TaskRunnerHelper::Get(TaskType::kUnspecedTimer, GetWorkerThread())
       ->PostTask(
           BLINK_FROM_HERE,
           CrossThreadBind(&ThreadedWorkletThreadForTest::CountFeature,
                           CrossThreadUnretained(GetWorkerThread()), kFeature1));
   testing::EnterRunLoop();
   EXPECT_TRUE(UseCounter::IsCounted(GetDocument(), kFeature1));
 
+  // API use should be reported to the Document only one time. See comments in
+  // ThreadedWorkletGlobalScopeForTest::CountFeature.
+  TaskRunnerHelper::Get(TaskType::kUnspecedTimer, GetWorkerThread())
+      ->PostTask(
+          BLINK_FROM_HERE,
+          CrossThreadBind(&ThreadedWorkletThreadForTest::CountFeature,
+                          CrossThreadUnretained(GetWorkerThread()), kFeature1));
+  testing::EnterRunLoop();
+
   // This feature is randomly selected from Deprecation::deprecationMessage().
   const UseCounter::Feature kFeature2 =
       UseCounter::Feature::kPrefixedStorageInfo;
 
   // Deprecated API use on the ThreadedWorkletGlobalScope should be recorded in
   // UseCounter on the Document.
   EXPECT_FALSE(UseCounter::IsCounted(GetDocument(), kFeature2));
   TaskRunnerHelper::Get(TaskType::kUnspecedTimer, GetWorkerThread())
       ->PostTask(
           BLINK_FROM_HERE,
           CrossThreadBind(&ThreadedWorkletThreadForTest::CountDeprecation,
                           CrossThreadUnretained(GetWorkerThread()), kFeature2));
   testing::EnterRunLoop();
   EXPECT_TRUE(UseCounter::IsCounted(GetDocument(), kFeature2));
+
+  // API use should be reported to the Document only one time. See comments in
+  // ThreadedWorkletGlobalScopeForTest::CountDeprecation.
+  TaskRunnerHelper::Get(TaskType::kUnspecedTimer, GetWorkerThread())
+      ->PostTask(
+          BLINK_FROM_HERE,
+          CrossThreadBind(&ThreadedWorkletThreadForTest::CountDeprecation,
+                          CrossThreadUnretained(GetWorkerThread()), kFeature2));
+  testing::EnterRunLoop();
 }
 
 }  // namespace blink