Tracing V2: Fully-functional plugin.

components/tracing/core/proto_zero_message_handle.h

 // 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.
 
 #ifndef COMPONENTS_TRACING_CORE_PROTO_ZERO_MESSAGE_HANDLE_H_
 #define COMPONENTS_TRACING_CORE_PROTO_ZERO_MESSAGE_HANDLE_H_
 
+#include <stdint.h>
+
+#include <string>
+#include <unordered_set>
+
+#include "base/logging.h"
 #include "base/macros.h"
 #include "components/tracing/tracing_export.h"
 
 namespace tracing {
 namespace v2 {
 
 class ProtoZeroMessage;
 
 // ProtoZeroMessageHandle allows to decouple the lifetime of a proto message
 // from the underlying storage. It gives the following guarantees:
 // - The underlying message is finalized (if still alive) if the handle goes
 //   out of scope.
 // - In Debug / DCHECK_ALWAYS_ON builds, the handle becomes null once the
 //   message is finalized. This is to enforce the append-only API. For instance
 //   when adding two repeated messages, the addition of the 2nd one forces
 //   the finalization of the first.
 // Think about this as a WeakPtr<ProtoZeroMessage> which calls
 // ProtoZeroMessage::Finalize() when going out of scope.
 
 class TRACING_EXPORT ProtoZeroMessageHandleBase {
  public:
   ~ProtoZeroMessageHandleBase();
 
   // Move-only type.
   ProtoZeroMessageHandleBase(ProtoZeroMessageHandleBase&& other);
   ProtoZeroMessageHandleBase& operator=(ProtoZeroMessageHandleBase&& other);
 
+  inline void SealField(uint32_t field_id) {

[Primiano Tucci (use gerrit), 2016/08/24 08:59:45]

wait why sealfield is a property of the Handle?
The handle is supposed to be just a transparent adaptor.
Please don't add anything to that. THe idea is that if the handle become a
bottleneck we can just short-circuit to ProtoZeroMessage.
Also, really, the fact that the sealed fields is here feels a hack to me.

Also note how this handle has move constructors.

+    DCHECK(sealed_fields_.count(field_id) == 0) <<
+        "Field (" + std::to_string(field_id) + ") can't be sealed again.";
+    sealed_fields_.insert(field_id);
+  }
+
  protected:
   explicit ProtoZeroMessageHandleBase(ProtoZeroMessage*);
   ProtoZeroMessage& operator*() const { return *message_; }
   ProtoZeroMessage* operator->() const { return message_; }
 
  private:
   friend class ProtoZeroMessage;
 
-  void reset_message() { message_ = nullptr; }
+  void reset_message() {
+    message_ = nullptr;
+    sealed_fields_.clear();
+  }
   void Move(ProtoZeroMessageHandleBase* other);
 
   ProtoZeroMessage* message_;
+  std::unordered_set<uint32_t> sealed_fields_;
 
   DISALLOW_COPY_AND_ASSIGN(ProtoZeroMessageHandleBase);
 };
 
 template <typename T>
-class ProtoZeroMessageHandle : ProtoZeroMessageHandleBase {
+class ProtoZeroMessageHandle : public ProtoZeroMessageHandleBase {
  public:
   explicit ProtoZeroMessageHandle(T* message)
       : ProtoZeroMessageHandleBase(message) {}
 
   T& operator*() const {
     return static_cast<T&>(ProtoZeroMessageHandleBase::operator*());
   }
 
   T* operator->() const {
     return static_cast<T*>(ProtoZeroMessageHandleBase::operator->());
   }
 };
 
 }  // namespace v2
 }  // namespace tracing
 
 #endif  // COMPONENTS_TRACING_CORE_PROTO_ZERO_MESSAGE_HANDLE_H_