tracing: the recorder implementation

services/resource_coordinator/tracing/recorder.cc

+// 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 "services/resource_coordinator/tracing/recorder.h"
+
+#include "base/callback_forward.h"
+#include "base/memory/ref_counted.h"
+#include "base/sequenced_task_runner.h"
+#include "services/resource_coordinator/public/interfaces/tracing/tracing.mojom.h"
+
+namespace tracing {
+
+Recorder::Recorder(
+    mojom::RecorderRequest request,
+    bool is_array,
+    const base::Closure& recorder_change_callback,
+    const scoped_refptr<base::SequencedTaskRunner>& background_task_runner)
+    : is_recording_(true),
+      is_array_(is_array),
+      recorder_change_callback_(recorder_change_callback),
+      background_task_runner_(background_task_runner),
+      binding_(this, std::move(request)) {
+  binding_.set_connection_error_handler(base::BindRepeating(
+      &Recorder::OnConnectionError, base::Unretained(this)));

[Primiano Tucci (use gerrit), 2017/05/25 13:15:01]

Is this class going to be long lived?
If yes, please add a documentational NOTREACHED() in the Recorder dtor (or at
least a comment)
If no, base::Unretained is unsafe here and you should use weakptr probably

[chiniforooshan, 2017/05/25 15:34:24]

It's not long lived, but it's deleted after the connection is closed (i.e. after
base::Unretained is used). I made it a weak pointer.

+}
+
+Recorder::~Recorder() {}
+
+void Recorder::AddChunk(const std::string& chunk) {
+  if (chunk.size() == 0)

[Primiano Tucci (use gerrit), 2017/05/25 13:15:01]

chunk.empty() 

[chiniforooshan, 2017/05/25 15:34:24]

Done.

+    return;
+  if (!background_task_runner_->RunsTasksOnCurrentThread()) {
+    background_task_runner_->PostTask(
+        FROM_HERE, base::BindRepeating(&Recorder::AddChunk,
+                                       base::Unretained(this), chunk));
+    return;
+  }
+  if (is_array_ && data_.size() > 0)
+    data_.append(",");
+  data_.append(chunk);
+  recorder_change_callback_.Run();
+}
+
+void Recorder::AddMetadata(std::unique_ptr<base::DictionaryValue> metadata) {
+  metadata_.MergeDictionary(metadata.get());
+}
+
+void Recorder::OnConnectionError() {
+  is_recording_ = false;
+  background_task_runner_->PostTask(FROM_HERE, recorder_change_callback_);
+}
+
+}  // namespace tracing