Worker: Enable UseCounter for SharedWorkerGlobalScope

content/common/worker_use_counter.cc

Index: content/common/worker_use_counter.cc
diff --git a/content/common/worker_use_counter.cc b/content/common/worker_use_counter.cc
new file mode 100644
index 0000000000000000000000000000000000000000..538903db2cf4edc1b0c40c2ade78fc946b7adecd
--- /dev/null
+++ b/content/common/worker_use_counter.cc
@@ -0,0 +1,56 @@
+// Copyright 2017 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 "content/common/worker_use_counter.h"
+
+#include "base/memory/ptr_util.h"
+
+namespace content {
+
+// Used for reserving a buffer of a bit vector. If a feature count is larger
+// than this buffer size, it's expanded on Count().
+// TODO(nhiroki): How do we synchronize this with UseCounter::Feature?
+const size_t kNumberOfFeatures = 2048;
+
+const size_t kBitsPerByte = 8;
+constexpr size_t kNumberOfBytes = kNumberOfFeatures / kBitsPerByte;

[kinuko, 2017/01/24 13:56:31]

Do we need to use vector<char> here?  Maybe we could just use std::bitset, and
bitset::to_string and bitset(string) for serialization?

[nhiroki, 2017/01/24 15:07:30]

I think std::bitset is a good option. Before moving to that, let me confirm 2
things...

std::bitset::to_string returns flags as a character string, that is, 1 bit is
converted to 1 byte. If UseCoutner::Feature has 2000 features, size of the
string is 2KB and every SharedWorker connection / ServiceWorker association
causes 2KB data transfer over IPC. Is this acceptable in terms of performance? I
feel it'd be acceptable, but I'm not really sure.

std::bitset requires a bit length as a type parameter like std::bitset<N>, so
it's necessary to get the number of UseCounter::Feature on compile time here. Do
you think adding a public header (WebUseCounter.h??) to expose the size of
UseCounter::Feature is reasonable?

[kinuko, 2017/01/25 05:12:52]

Usually sending IPC up to 2KB doesn't make a lot difference, but I agree that it
might sound a little wasteful.

How many features are usually flipped on or off?  Could using SmallMap<int,
bool> be better? (Then we get IPC serializers for free)
I thought about just use kNumberOfFeatures and asserts on the size so that the
code can be synchronized.

[nhiroki, 2017/01/25 10:16:11]

I think it's not so big for now because most of features are available only on
Document (e.g., DOM, CSS).

std::set SGTM. Replaced WorkerUseCounter with std::set.
Thanks. std::set does not need the max number, so I didn't add a public header
or an assertion.

+
+WorkerUseCounter::WorkerUseCounter()
+    : counter_(std::vector<char>(kNumberOfBytes)) {
+}
+
+WorkerUseCounter::WorkerUseCounter(std::vector<char> counter)
+    : counter_(counter) {
+}
+
+WorkerUseCounter::~WorkerUseCounter() = default;
+
+void WorkerUseCounter::Count(uint32_t feature) {
+  size_t byte_pos = feature / kBitsPerByte;
+  size_t bit_pos = feature % kBitsPerByte;
+  char bit_mask = 0x1 << bit_pos;
+  if (counter_.size() < byte_pos)
+    counter_.resize(byte_pos + 1);
+  counter_[byte_pos] |= bit_mask;
+}
+
+bool WorkerUseCounter::IsCounted(uint32_t feature) {
+  size_t byte_pos = feature / kBitsPerByte;
+  size_t bit_pos = feature % kBitsPerByte;
+  if (counter_.size() < byte_pos)
+    return false;
+  char bit_mask = 0x1 << bit_pos;
+  return (counter_[byte_pos] & bit_mask) != 0;
+}
+
+std::vector<char> WorkerUseCounter::Dump() {
+  return counter_;
+}
+
+size_t WorkerUseCounter::GetNumberOfBits() const {
+  size_t number_of_bytes = counter_.size();
+  return number_of_bytes * kBitsPerByte;
+}
+
+}  // namespace content