tracing: Make ConvertableToTraceFormat move-only scoped_ptr

base/trace_event/trace_event_unittest.cc

Index: base/trace_event/trace_event_unittest.cc
diff --git a/base/trace_event/trace_event_unittest.cc b/base/trace_event/trace_event_unittest.cc
index eea84b9cbe22326af0e7835acbd7e6d147990fea..c98c698b6aafb89d70c428ab5b163e1b8907924e 100644
--- a/base/trace_event/trace_event_unittest.cc
+++ b/base/trace_event/trace_event_unittest.cc
@@ -1237,37 +1237,41 @@ TEST_F(TraceEventTestFixture, AddMetadataEvent) {
   class Convertable : public ConvertableToTraceFormat {
    public:
     explicit Convertable(int* num_calls) : num_calls_(num_calls) {}
+    ~Convertable() override {}
     void AppendAsTraceFormat(std::string* out) const override {
       (*num_calls_)++;
       out->append("\"metadata_value\"");
     }
 
    private:
-    ~Convertable() override {}
     int* num_calls_;
   };
 
-  scoped_refptr<ConvertableToTraceFormat> convertable =
-      new Convertable(&num_calls);
+  scoped_ptr<ConvertableToTraceFormat> conv1(new Convertable(&num_calls));
+  scoped_ptr<Convertable> conv2(new Convertable(&num_calls));
 
   BeginTrace();
   TRACE_EVENT_API_ADD_METADATA_EVENT(
-      TraceLog::GetCategoryGroupEnabled("__metadata"), "metadata_event_name",
-      "metadata_arg_name", convertable);
-
+      TraceLog::GetCategoryGroupEnabled("__metadata"), "metadata_event_1",
+      "metadata_arg_name", std::move(conv1));
+  TRACE_EVENT_API_ADD_METADATA_EVENT(
+      TraceLog::GetCategoryGroupEnabled("__metadata"), "metadata_event_2",
+      "metadata_arg_name", std::move(conv2));
   // |AppendAsTraceFormat| should only be called on flush, not when the event
   // is added.
   ASSERT_EQ(0, num_calls);
   EndTraceAndFlush();
-  ASSERT_EQ(1, num_calls);
-  EXPECT_TRUE(FindNamePhaseKeyValue("metadata_event_name", "M",
+  ASSERT_EQ(2, num_calls);
+  EXPECT_TRUE(FindNamePhaseKeyValue("metadata_event_1", "M",
+                                    "metadata_arg_name", "metadata_value"));
+  EXPECT_TRUE(FindNamePhaseKeyValue("metadata_event_2", "M",
                                     "metadata_arg_name", "metadata_value"));
 
   // The metadata event should only be adde to the current trace. In this new
   // trace, the event should not appear.
   BeginTrace();
   EndTraceAndFlush();
-  ASSERT_EQ(1, num_calls);
+  ASSERT_EQ(2, num_calls);
 }
 
 // Test that categories work.
@@ -2036,13 +2040,13 @@ TEST_F(TraceEventTestFixture, TraceSamplingScope) {
 class MyData : public ConvertableToTraceFormat {
  public:
   MyData() {}
+  ~MyData() override {}
 
   void AppendAsTraceFormat(std::string* out) const override {
     out->append("{\"foo\":1}");
   }
 
  private:
-  ~MyData() override {}
   DISALLOW_COPY_AND_ASSIGN(MyData);
 };
 
@@ -2050,31 +2054,25 @@ TEST_F(TraceEventTestFixture, ConvertableTypes) {
   TraceLog::GetInstance()->SetEnabled(TraceConfig(kRecordAllCategoryFilter, ""),
                                       TraceLog::RECORDING_MODE);
 
-  scoped_refptr<ConvertableToTraceFormat> data(new MyData());
-  scoped_refptr<ConvertableToTraceFormat> data1(new MyData());
-  scoped_refptr<ConvertableToTraceFormat> data2(new MyData());
-  TRACE_EVENT1("foo", "bar", "data", data);
-  TRACE_EVENT2("foo", "baz",
-               "data1", data1,
-               "data2", data2);
-
-
-  scoped_refptr<ConvertableToTraceFormat> convertData1(new MyData());
-  scoped_refptr<ConvertableToTraceFormat> convertData2(new MyData());
-  TRACE_EVENT2(
-      "foo",
-      "string_first",
-      "str",
-      "string value 1",
-      "convert",
-      convertData1);
-  TRACE_EVENT2(
-      "foo",
-      "string_second",
-      "convert",
-      convertData2,
-      "str",
-      "string value 2");
+  scoped_ptr<ConvertableToTraceFormat> data(new MyData());
+  scoped_ptr<ConvertableToTraceFormat> data1(new MyData());
+  scoped_ptr<ConvertableToTraceFormat> data2(new MyData());
+  TRACE_EVENT1("foo", "bar", "data", std::move(data));
+  TRACE_EVENT2("foo", "baz", "data1", std::move(data1), "data2",
+               std::move(data2));
+
+  // Check that scoped_ptr<DerivedClassOfConvertable> are properly treated as
+  // convertable and not accidentally casted to bool.
+  scoped_ptr<MyData> convertData1(new MyData());
+  scoped_ptr<MyData> convertData2(new MyData());
+  scoped_ptr<MyData> convertData3(new MyData());
+  scoped_ptr<MyData> convertData4(new MyData());
+  TRACE_EVENT2("foo", "string_first", "str", "string value 1", "convert",
+               std::move(convertData1));
+  TRACE_EVENT2("foo", "string_second", "convert", std::move(convertData2),
+               "str", "string value 2");
+  TRACE_EVENT2("foo", "both_conv", "convert1", std::move(convertData3),
+               "convert2", std::move(convertData4));
   EndTraceAndFlush();
 
   // One arg version.
@@ -2149,6 +2147,21 @@ TEST_F(TraceEventTestFixture, ConvertableTypes) {
   ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
   EXPECT_TRUE(convertable_dict->GetInteger("foo", &foo_val));
   EXPECT_EQ(1, foo_val);
+
+  dict = FindNamePhase("both_conv", "X");
+  ASSERT_TRUE(dict);
+
+  args_dict = NULL;
+  dict->GetDictionary("args", &args_dict);
+  ASSERT_TRUE(args_dict);
+
+  value = NULL;
+  convertable_dict = NULL;
+  foo_val = 0;
+  EXPECT_TRUE(args_dict->Get("convert1", &value));
+  ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
+  EXPECT_TRUE(args_dict->Get("convert2", &value));
+  ASSERT_TRUE(value->GetAsDictionary(&convertable_dict));
 }
 
 TEST_F(TraceEventTestFixture, PrimitiveArgs) {