Worker: Avoid sending IPC messages for features already counted

third_party/WebKit/Source/core/workers/DedicatedWorkerTest.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 <memory>
 #include "core/dom/TaskRunnerHelper.h"
 #include "core/events/MessageEvent.h"
 #include "core/inspector/ConsoleMessageStorage.h"
 #include "core/testing/DummyPageHolder.h"
 #include "core/workers/DedicatedWorkerGlobalScope.h"
@@ skipping 49 matching lines @@
     EXPECT_TRUE(IsCurrentThread());
     GlobalScope()->CountFeature(feature);
     GetParentFrameTaskRunners()
         ->Get(TaskType::kUnspecedTimer)
         ->PostTask(BLINK_FROM_HERE, CrossThreadBind(&testing::ExitRunLoop));
   }
 
   // Emulates deprecated API use on DedicatedWorkerGlobalScope.
   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 InProcessWorkerObjectProxyForTest final
+    : public InProcessWorkerObjectProxy {
+ public:
+  InProcessWorkerObjectProxyForTest(
+      const WeakPtr<InProcessWorkerMessagingProxy>& messaging_proxy_weak_ptr,
+      ParentFrameTaskRunners* parent_frame_task_runners)
+      : InProcessWorkerObjectProxy(messaging_proxy_weak_ptr,
+                                   parent_frame_task_runners),
+        reported_features_(UseCounter::kNumberOfFeatures) {
+    default_interval_in_sec_ = kDefaultIntervalInSec;
+    next_interval_in_sec_ = kNextIntervalInSec;
+    max_interval_in_sec_ = kMaxIntervalInSec;
+  }
+
+  void CountFeature(UseCounter::Feature feature) override {
+    // Any feature should be reported only one time.
+    EXPECT_FALSE(reported_features_.QuickGet(feature));
+    reported_features_.QuickSet(feature);
+    InProcessWorkerObjectProxy::CountFeature(feature);
+  }
+
+  void CountDeprecation(UseCounter::Feature feature) override {
+    // Any feature should be reported only one time.
+    EXPECT_FALSE(reported_features_.QuickGet(feature));
+    reported_features_.QuickSet(feature);
+    InProcessWorkerObjectProxy::CountDeprecation(feature);
+  }
+
+ private:
+  BitVector reported_features_;
+};
+
 class InProcessWorkerMessagingProxyForTest
     : public InProcessWorkerMessagingProxy {
  public:
   InProcessWorkerMessagingProxyForTest(ExecutionContext* execution_context)
       : InProcessWorkerMessagingProxy(execution_context,
                                       nullptr /* workerObject */,
                                       nullptr /* workerClients */) {
-    WorkerObjectProxy().default_interval_in_sec_ = kDefaultIntervalInSec;
-    WorkerObjectProxy().next_interval_in_sec_ = kNextIntervalInSec;
-    WorkerObjectProxy().max_interval_in_sec_ = kMaxIntervalInSec;
-
+    worker_object_proxy_ = WTF::MakeUnique<InProcessWorkerObjectProxyForTest>(
+        weak_ptr_factory_.CreateWeakPtr(), GetParentFrameTaskRunners());
     worker_loader_proxy_provider_ =
         WTF::MakeUnique<WorkerLoaderProxyProvider>();
     worker_thread_ = WTF::WrapUnique(new DedicatedWorkerThreadForTest(
         worker_loader_proxy_provider_.get(), WorkerObjectProxy()));
     mock_worker_thread_lifecycle_observer_ =
         new MockWorkerThreadLifecycleObserver(
             worker_thread_->GetWorkerThreadLifecycleContext());
     EXPECT_CALL(*mock_worker_thread_lifecycle_observer_,
                 ContextDestroyed(::testing::_))
         .Times(1);
@@ skipping 287 matching lines @@
   // on the Document.
   EXPECT_FALSE(UseCounter::IsCounted(GetDocument(), kFeature1));
   TaskRunnerHelper::Get(TaskType::kUnspecedTimer, GetWorkerThread())
       ->PostTask(
           BLINK_FROM_HERE,
           CrossThreadBind(&DedicatedWorkerThreadForTest::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
+  // InProcessWorkerObjectProxyForTest::CountFeature.
+  TaskRunnerHelper::Get(TaskType::kUnspecedTimer, GetWorkerThread())
+      ->PostTask(
+          BLINK_FROM_HERE,
+          CrossThreadBind(&DedicatedWorkerThreadForTest::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 DedicatedWorkerGlobalScope should be recorded in
   // UseCounter on the Document.
   EXPECT_FALSE(UseCounter::IsCounted(GetDocument(), kFeature2));
   TaskRunnerHelper::Get(TaskType::kUnspecedTimer, GetWorkerThread())
       ->PostTask(
           BLINK_FROM_HERE,
           CrossThreadBind(&DedicatedWorkerThreadForTest::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
+  // InProcessWorkerObjectProxyForTest::CountDeprecation.
+  TaskRunnerHelper::Get(TaskType::kUnspecedTimer, GetWorkerThread())
+      ->PostTask(
+          BLINK_FROM_HERE,
+          CrossThreadBind(&DedicatedWorkerThreadForTest::CountDeprecation,
+                          CrossThreadUnretained(GetWorkerThread()), kFeature2));
+  testing::EnterRunLoop();
 }
 
 }  // namespace blink