Use base::FooValue::From() to simplify gpu code.

gpu/tools/compositor_model_bench/compositor_model_bench.cc

 // Copyright (c) 2012 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.
 
 // This tool is used to benchmark the render model used by the compositor
 
 // Most of this file is derived from the source of the tile_render_bench tool,
 // and has been changed to  support running a sequence of independent
 // simulations for our different render models and test cases.
 
 #include <stdio.h>
 #include <sys/dir.h>
 #include <sys/file.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <X11/keysym.h>
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 
 #include <queue>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 20 matching lines @@
 };
 
 // Forward declarations
 class Simulator;
 void _process_events(Simulator* sim);
 void _update_loop(Simulator* sim);
 
 class Simulator {
  public:
   Simulator(int seconds_per_test, const base::FilePath& output_path)
-     : current_sim_(NULL),
-       output_path_(output_path),
-       seconds_per_test_(seconds_per_test),
-       display_(NULL),
-       window_(0),
-       gl_context_(NULL),
-       window_width_(WINDOW_WIDTH),
-       window_height_(WINDOW_HEIGHT),
-       weak_factory_(this) {
-  }
+      : output_path_(output_path),
+        seconds_per_test_(seconds_per_test),
+        display_(nullptr),
+        window_(0),
+        gl_context_(nullptr),
+        window_width_(WINDOW_WIDTH),
+        window_height_(WINDOW_HEIGHT),
+        weak_factory_(this) {}
 
   ~Simulator() {
     // Cleanup GL.
-    glXMakeCurrent(display_, 0, NULL);
+    glXMakeCurrent(display_, 0, nullptr);
     glXDestroyContext(display_, gl_context_);
 
     // Destroy window and display.
     XDestroyWindow(display_, window_);
     XCloseDisplay(display_);
   }
 
   void QueueTest(const base::FilePath& path) {
     SimulationSpecification spec;
 
@@ skipping 60 matching lines @@
 
   void UpdateLoop() {
     if (UpdateTestStatus())
       UpdateCurrentTest();
   }
 
  private:
   // Initialize X11. Returns true if successful. This method creates the
   // X11 window. Further initialization is done in X11VideoRenderer.
   bool InitX11() {
-    display_ = XOpenDisplay(NULL);
+    display_ = XOpenDisplay(nullptr);
     if (!display_) {
       LOG(FATAL) << "Cannot open display";
       return false;
     }
 
     // Get properties of the screen.
     int screen = DefaultScreen(display_);
     int root_window = RootWindow(display_, screen);
 
     // Creates the window.
@@ skipping 38 matching lines @@
                                      True /* Direct rendering */);
     }
 
     XFree(visual_info_list);
     if (!gl_context_) {
       return false;
     }
 
     if (!glXMakeCurrent(display_, window_, gl_context_)) {
       glXDestroyContext(display_, gl_context_);
-      gl_context_ = NULL;
+      gl_context_ = nullptr;
       return false;
     }
 
     return true;
   }
 
   bool InitializeNextTest() {
     SimulationSpecification& spec = sims_remaining_.front();
-    LOG(INFO) << "Initializing test for " << spec.simulation_name <<
-        "(" << ModelToString(spec.model_under_test) << ")";
+    LOG(INFO) << "Initializing test for " << spec.simulation_name << "("
+              << ModelToString(spec.model_under_test) << ")";
     const base::FilePath& path = spec.input_path;
 
-    RenderNode* root = NULL;
-    if (!(root = BuildRenderTreeFromFile(path))) {
-      LOG(ERROR) << "Couldn't parse test configuration file " <<
-          path.LossyDisplayName();
+    std::unique_ptr<RenderNode> root = BuildRenderTreeFromFile(path);
+    if (!root) {
+      LOG(ERROR) << "Couldn't parse test configuration file "
+                 << path.LossyDisplayName();
       return false;
     }
 
-    current_sim_ = ConstructSimulationModel(spec.model_under_test,
-                                            root,
-                                            window_width_,
-                                            window_height_);
-    if (!current_sim_)
-      return false;
-
-    return true;
+    current_sim_ = ConstructSimulationModel(
+        spec.model_under_test, std::move(root), window_width_, window_height_);
+    return !!current_sim_;
   }
 
   void CleanupCurrentTest() {
     LOG(INFO) << "Finished test " << sims_remaining_.front().simulation_name;
 
-    delete current_sim_;
-    current_sim_ = NULL;
+    current_sim_.reset();
   }
 
   void UpdateCurrentTest() {
     ++sims_remaining_.front().frames_rendered;
 
     if (current_sim_)
       current_sim_->Update();
 
     glXSwapBuffers(display_, window_);
 
     XExposeEvent ev = { Expose, 0, 1, display_, window_,
                         0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0 };
     XSendEvent(display_,
       window_,
       False,
       ExposureMask,
       reinterpret_cast<XEvent*>(&ev));
 
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&Simulator::UpdateLoop, weak_factory_.GetWeakPtr()));
   }
 
   void DumpOutput() {
     LOG(INFO) << "Successfully ran " << sims_completed_.size() << " tests";
 
     FILE* f = base::OpenFile(output_path_, "w");
 
     if (!f) {
-      LOG(ERROR) << "Failed to open output file " <<
-        output_path_.LossyDisplayName();
+      LOG(ERROR) << "Failed to open output file "
+                 << output_path_.LossyDisplayName();
       exit(-1);
     }
 
     LOG(INFO) << "Writing results to " << output_path_.LossyDisplayName();
 
     fputs("{\n\t\"results\": [\n", f);
 
     while (sims_completed_.size()) {
       SimulationSpecification i = sims_completed_.front();
       fprintf(f,
@@ skipping 40 matching lines @@
   }
 
   void Resize(int width, int height) {
     window_width_ = width;
     window_height_ = height;
     if (current_sim_)
       current_sim_->Resize(window_width_, window_height_);
   }
 
   // Simulation task list for this execution
-  RenderModelSimulator* current_sim_;
+  std::unique_ptr<RenderModelSimulator> current_sim_;
   queue<SimulationSpecification> sims_remaining_;
   queue<SimulationSpecification> sims_completed_;
   base::FilePath output_path_;
   // Amount of time to run each simulation
   int seconds_per_test_;
   // GUI data
   Display* display_;
   Window window_;
   GLXContext gl_context_;
   int window_width_;
@@ skipping 41 matching lines @@
     }
   } else {
     LOG(INFO) << "(input path is a file)";
     sim.QueueTest(inPath);
   }
 
   sim.Run();
 
   return 0;
 }