Revert of Add builders for tracing event's structural arguments

cc/scheduler/scheduler_unittest.cc

 // Copyright 2011 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 "cc/scheduler/scheduler.h"
 
 #include <string>
 #include <vector>
 
-#include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/time/time.h"
 #include "cc/test/begin_frame_args_test.h"
 #include "cc/test/ordered_simple_task_runner.h"
 #include "cc/test/scheduler_test_common.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 84 matching lines @@
 
   // Most tests don't care about DidAnticipatedDrawTimeChange, so only record it
   // for tests that do.
   void set_log_anticipated_draw_time_change(bool log) {
     log_anticipated_draw_time_change_ = log;
   }
   bool needs_begin_frame() { return needs_begin_frame_; }
   int num_draws() const { return num_draws_; }
   int num_actions_() const { return static_cast<int>(actions_.size()); }
   const char* Action(int i) const { return actions_[i]; }
-  std::string StateForAction(int i) const { return states_[i]->ToString(); }
+  base::Value& StateForAction(int i) const { return *states_[i]; }
   base::TimeTicks posted_begin_impl_frame_deadline() const {
     return posted_begin_impl_frame_deadline_;
   }
 
   OrderedSimpleTaskRunner& task_runner() { return *task_runner_; }
 
   int ActionIndex(const char* action) const {
     for (size_t i = 0; i < actions_.size(); i++)
       if (!strcmp(actions_[i], action))
         return i;
@@ skipping 16 matching lines @@
   }
   void SetAutomaticSwapAck(bool automatic_swap_ack) {
     automatic_swap_ack_ = automatic_swap_ack;
   }
   void SetRedrawWillHappenIfUpdateVisibleTilesHappens(bool redraw) {
     redraw_will_happen_if_update_visible_tiles_happens_ = redraw;
   }
   // SchedulerClient implementation.
   virtual void SetNeedsBeginFrame(bool enable) OVERRIDE {
     actions_.push_back("SetNeedsBeginFrame");
-    states_.push_back(scheduler_->AsValue());
+    states_.push_back(scheduler_->AsValue().release());
     needs_begin_frame_ = enable;
   }
   virtual void WillBeginImplFrame(const BeginFrameArgs& args) OVERRIDE {
     actions_.push_back("WillBeginImplFrame");
-    states_.push_back(scheduler_->AsValue());
+    states_.push_back(scheduler_->AsValue().release());
   }
   virtual void ScheduledActionSendBeginMainFrame() OVERRIDE {
     actions_.push_back("ScheduledActionSendBeginMainFrame");
-    states_.push_back(scheduler_->AsValue());
+    states_.push_back(scheduler_->AsValue().release());
   }
   virtual void ScheduledActionAnimate() OVERRIDE {
     actions_.push_back("ScheduledActionAnimate");
-    states_.push_back(scheduler_->AsValue());
+    states_.push_back(scheduler_->AsValue().release());
   }
   virtual DrawResult ScheduledActionDrawAndSwapIfPossible() OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapIfPossible");
-    states_.push_back(scheduler_->AsValue());
+    states_.push_back(scheduler_->AsValue().release());
     num_draws_++;
     DrawResult result =
         draw_will_happen_ ? DRAW_SUCCESS : DRAW_ABORTED_CHECKERBOARD_ANIMATIONS;
     bool swap_will_happen =
         draw_will_happen_ && swap_will_happen_if_draw_happens_;
     if (swap_will_happen) {
       scheduler_->DidSwapBuffers();
       if (swap_contains_incomplete_tile_) {
         scheduler_->SetSwapUsedIncompleteTile(true);
         swap_contains_incomplete_tile_ = false;
       } else {
         scheduler_->SetSwapUsedIncompleteTile(false);
       }
 
       if (automatic_swap_ack_)
         scheduler_->DidSwapBuffersComplete();
     }
     return result;
   }
   virtual DrawResult ScheduledActionDrawAndSwapForced() OVERRIDE {
     actions_.push_back("ScheduledActionDrawAndSwapForced");
-    states_.push_back(scheduler_->AsValue());
+    states_.push_back(scheduler_->AsValue().release());
     return DRAW_SUCCESS;
   }
   virtual void ScheduledActionCommit() OVERRIDE {
     actions_.push_back("ScheduledActionCommit");
-    states_.push_back(scheduler_->AsValue());
+    states_.push_back(scheduler_->AsValue().release());
   }
   virtual void ScheduledActionUpdateVisibleTiles() OVERRIDE {
     actions_.push_back("ScheduledActionUpdateVisibleTiles");
-    states_.push_back(scheduler_->AsValue());
+    states_.push_back(scheduler_->AsValue().release());
     if (redraw_will_happen_if_update_visible_tiles_happens_)
       scheduler_->SetNeedsRedraw();
   }
   virtual void ScheduledActionActivateSyncTree() OVERRIDE {
     actions_.push_back("ScheduledActionActivateSyncTree");
-    states_.push_back(scheduler_->AsValue());
+    states_.push_back(scheduler_->AsValue().release());
   }
   virtual void ScheduledActionBeginOutputSurfaceCreation() OVERRIDE {
     actions_.push_back("ScheduledActionBeginOutputSurfaceCreation");
-    states_.push_back(scheduler_->AsValue());
+    states_.push_back(scheduler_->AsValue().release());
   }
   virtual void ScheduledActionManageTiles() OVERRIDE {
     actions_.push_back("ScheduledActionManageTiles");
-    states_.push_back(scheduler_->AsValue());
+    states_.push_back(scheduler_->AsValue().release());
   }
   virtual void DidAnticipatedDrawTimeChange(base::TimeTicks) OVERRIDE {
     if (log_anticipated_draw_time_change_)
       actions_.push_back("DidAnticipatedDrawTimeChange");
   }
   virtual base::TimeDelta DrawDurationEstimate() OVERRIDE {
     return base::TimeDelta();
   }
   virtual base::TimeDelta BeginMainFrameToCommitDurationEstimate() OVERRIDE {
     return base::TimeDelta();
   }
   virtual base::TimeDelta CommitToActivateDurationEstimate() OVERRIDE {
     return base::TimeDelta();
   }
 
   virtual void DidBeginImplFrameDeadline() OVERRIDE {}
 
  protected:
   bool needs_begin_frame_;
   bool draw_will_happen_;
   bool swap_will_happen_if_draw_happens_;
   bool automatic_swap_ack_;
   int num_draws_;
   bool log_anticipated_draw_time_change_;
   bool swap_contains_incomplete_tile_;
   bool redraw_will_happen_if_update_visible_tiles_happens_;
   base::TimeTicks posted_begin_impl_frame_deadline_;
   std::vector<const char*> actions_;
-  std::vector<scoped_refptr<base::debug::ConvertableToTraceFormat> > states_;
+  ScopedVector<base::Value> states_;
   scoped_ptr<TestScheduler> scheduler_;
   scoped_refptr<OrderedSimpleTaskRunner> task_runner_;
 };
 
 void InitializeOutputSurfaceAndFirstCommit(Scheduler* scheduler,
                                            FakeSchedulerClient* client) {
   bool client_initiates_begin_frame =
       scheduler->settings().begin_frame_scheduling_enabled &&
       scheduler->settings().throttle_frame_production;
 
@@ skipping 908 matching lines @@
   scheduler->DidSwapBuffers();
 
   // Spin the event loop a few times and make sure we get more
   // DidAnticipateDrawTimeChange calls every time.
   int actions_so_far = client.num_actions_();
 
   // Does three iterations to make sure that the timer is properly repeating.
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ((frame_args.interval * 2).InMicroseconds(),
               client.task_runner().NextPendingTaskDelay().InMicroseconds())
-        << scheduler->AsValue()->ToString();
+        << *scheduler->AsValue();
     client.task_runner().RunPendingTasks();
     EXPECT_GT(client.num_actions_(), actions_so_far);
     EXPECT_STREQ(client.Action(client.num_actions_() - 1),
                  "DidAnticipatedDrawTimeChange");
     actions_so_far = client.num_actions_();
   }
 
   // Do the same thing after BeginMainFrame starts but still before activation.
   scheduler->NotifyBeginMainFrameStarted();
   for (int i = 0; i < 3; ++i) {
     EXPECT_EQ((frame_args.interval * 2).InMicroseconds(),
               client.task_runner().NextPendingTaskDelay().InMicroseconds())
-        << scheduler->AsValue()->ToString();
+        << *scheduler->AsValue();
     client.task_runner().RunPendingTasks();
     EXPECT_GT(client.num_actions_(), actions_so_far);
     EXPECT_STREQ(client.Action(client.num_actions_() - 1),
                  "DidAnticipatedDrawTimeChange");
     actions_so_far = client.num_actions_();
   }
 }
 
 TEST(SchedulerTest, BeginRetroFrame) {
   FakeSchedulerClient client;
@@ skipping 717 matching lines @@
   EXPECT_FALSE(scheduler->IsSyntheticBeginFrameSourceActive());
 
   client.Reset();
   client.task_runner().RunPendingTasks();  // Run posted deadline.
   EXPECT_SINGLE_ACTION("ScheduledActionBeginOutputSurfaceCreation", client);
   EXPECT_FALSE(scheduler->IsSyntheticBeginFrameSourceActive());
 }
 
 }  // namespace
 }  // namespace cc