tracing v2: Introduce handles for safe usage of ProtoZeroMessage

components/tracing/core/proto_zero_message_handle.h

Index: components/tracing/core/proto_zero_message_handle.h
diff --git a/components/tracing/core/proto_zero_message_handle.h b/components/tracing/core/proto_zero_message_handle.h
new file mode 100644
index 0000000000000000000000000000000000000000..a2fbd8677321879ff14ecf0ae7a3e80e5310c1d5
--- /dev/null
+++ b/components/tracing/core/proto_zero_message_handle.h
@@ -0,0 +1,71 @@
+// 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 "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 when adding two repeated messages, the addition of the 2nd one forces

[alph, 2016/07/20 18:35:00]

double when

[Primiano Tucci (use gerrit), 2016/07/21 10:50:03]

Done.

+//   the finalization of the first.
+// Think to this as a WeakPtr<ProtoZeroMessage> which calls

[oystein (OOO til 10th of July), 2016/07/20 21:19:37]

nit: s/to/about/

[Primiano Tucci (use gerrit), 2016/07/21 10:50:03]

Done.

+// ProtoZeroMessage::Finalize() when going out of scope.
+
+// Use the templated version below. This base class is just here to avoid

[alph, 2016/07/20 18:35:00]

no need to go into such explanation as this is the common pattern. protected
constructor would explain that.

[Primiano Tucci (use gerrit), 2016/07/21 10:50:03]

Oh good point. Also the protected ctor removes the need of deleting the generic
ctor in the template. Didn't think to that.

+// template code bloating.
+class TRACING_EXPORT ProtoZeroMessageHandleBase {
+ public:
+  explicit ProtoZeroMessageHandleBase(ProtoZeroMessage*);
+  ~ProtoZeroMessageHandleBase();
+
+  // Move-only type.
+  ProtoZeroMessageHandleBase(ProtoZeroMessageHandleBase&& other);
+  ProtoZeroMessageHandleBase& operator=(ProtoZeroMessageHandleBase&& other);
+
+  ProtoZeroMessage& operator*() const { return *message_; }
+  ProtoZeroMessage* operator->() const { return message_; }
+
+ private:
+  friend class ProtoZeroMessage;
+
+  void reset_message() { message_ = nullptr; }
+  void Move(ProtoZeroMessageHandleBase* other);
+
+  ProtoZeroMessage* message_;
+
+  DISALLOW_COPY_AND_ASSIGN(ProtoZeroMessageHandleBase);
+};
+
+template <typename T>
+class ProtoZeroMessageHandle : ProtoZeroMessageHandleBase {
+ public:
+  explicit ProtoZeroMessageHandle(ProtoZeroMessage*) = delete;
+  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_