base::Bind() conversion for compositor_model_bench.

gpu/tools/compositor_model_bench/compositor_model_bench.cc

 // Copyright (c) 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.
 
 // 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 <vector>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
-#include "base/task.h"
 #include "base/time.h"
 
 #include "gpu/tools/compositor_model_bench/render_model_utils.h"
 #include "gpu/tools/compositor_model_bench/render_models.h"
 #include "gpu/tools/compositor_model_bench/render_tree.h"
 
 
 using base::TimeTicks;
 using file_util::CloseFile;
 using file_util::DirectoryExists;
@@ skipping 16 matching lines @@
 void _process_events(Simulator* sim);
 void _update_loop(Simulator* sim);
 
 class Simulator {
  public:
   Simulator(int seconds_per_test, const FilePath& output_path)
      : running_(false),
        current_sim_(NULL),
        output_path_(output_path),
        seconds_per_test_(seconds_per_test),
-       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)),
        display_(NULL),
        window_(0),
        gl_context_(NULL),
        window_width_(WINDOW_WIDTH),
        window_height_(WINDOW_HEIGHT) {
   }
 
   ~Simulator() {
     // Cleanup GL.
     glXMakeCurrent(display_, 0, NULL);
@@ skipping 38 matching lines @@
     MessageLoop loop;
     if (!InitX11() || !InitGLContext()) {
       LOG(FATAL) << "Failed to set up GUI.";
     }
 
     InitBuffers();
 
     LOG(INFO) << "Running " << sims_remaining_.size() << " simulations.";
 
     loop.PostTask(FROM_HERE,
-                  method_factory_.NewRunnableMethod(&Simulator::ProcessEvents));
+                  base::Bind(&Simulator::ProcessEvents,
+                             weak_factory_.GetWeakPtr()));
     loop.Run();
   }
 
   void ProcessEvents() {
     // Consume all the X events.
     while (XPending(display_)) {
       XEvent e;
       XNextEvent(display_, &e);
       switch (e.type) {
         case Expose:
@@ skipping 124 matching lines @@
     XExposeEvent ev = { Expose, 0, 1, display_, window_,
                         0, 0, WINDOW_WIDTH, WINDOW_HEIGHT, 0 };
     XSendEvent(display_,
       window_,
       False,
       ExposureMask,
       reinterpret_cast<XEvent*>(&ev));
 
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        method_factory_.NewRunnableMethod(&Simulator::UpdateLoop));
+        base::Bind(&Simulator::UpdateLoop, weak_factory_.GetWeakPtr()));
   }
 
   void DumpOutput() {
     LOG(INFO) << "Successfully ran " << sims_completed_.size() << " tests";
 
     FILE* f = OpenFile(output_path_, "w");
 
     if (!f) {
       LOG(ERROR) << "Failed to open output file " <<
         output_path_.LossyDisplayName();
@@ skipping 58 matching lines @@
 
   // Simulation task list for this execution
   bool running_;
   RenderModelSimulator* current_sim_;
   queue<SimulationSpecification> sims_remaining_;
   queue<SimulationSpecification> sims_completed_;
   FilePath output_path_;
   // Amount of time to run each simulation
   int seconds_per_test_;
   // GUI data
-  ScopedRunnableMethodFactory<Simulator> method_factory_;
+  base::WeakPtrFactory<Simulator> weak_factory_;
   Display* display_;
   Window window_;
   GLXContext gl_context_;
   int window_width_;
   int window_height_;
 };
 
 int main(int argc, char* argv[]) {
   CommandLine::Init(argc, argv);
   const CommandLine* cl = CommandLine::ForCurrentProcess();
@@ skipping 34 matching lines @@
     }
   } else {
     LOG(INFO) << "(input path is a file)";
     sim.QueueTest(inPath);
   }
 
   sim.Run();
 
   return 0;
 }
-