Removes ContextFactory::Get/SetInstance

ui/aura/bench/bench_main.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.
 
 #if defined(USE_X11)
 #include <X11/Xlib.h>
 #endif
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 130 matching lines @@
                    bool is_lost) {
   gpu::gles2::GLES2Interface* gl = context_provider->ContextGL();
   gl->WaitSyncPointCHROMIUM(sync_point);
   gl->DeleteTextures(1, &texture);
   gl->ShallowFlushCHROMIUM();
 }
 
 // A benchmark that adds a texture layer that is updated every frame.
 class WebGLBench : public BenchCompositorObserver {
  public:
-  WebGLBench(Layer* parent, Compositor* compositor, int max_frames)
+  WebGLBench(ui::ContextFactory* context_factory,
+             Layer* parent,
+             Compositor* compositor,
+             int max_frames)
       : BenchCompositorObserver(max_frames),
         parent_(parent),
         webgl_(ui::LAYER_TEXTURED),
         compositor_(compositor),
         fbo_(0),
         do_draw_(true) {
     CommandLine* command_line = CommandLine::ForCurrentProcess();
     do_draw_ = !command_line->HasSwitch("disable-draw");
 
     std::string webgl_size = command_line->GetSwitchValueASCII("webgl-size");
     int width = 0;
     int height = 0;
     if (!webgl_size.empty()) {
       std::vector<std::string> split_size;
       base::SplitString(webgl_size, 'x', &split_size);
       if (split_size.size() == 2) {
         width = atoi(split_size[0].c_str());
         height = atoi(split_size[1].c_str());
       }
     }
     if (!width || !height) {
       width = 800;
       height = 600;
     }
     gfx::Rect bounds(width, height);
     webgl_.SetBounds(bounds);
     parent_->Add(&webgl_);
 
-    context_provider_ =
-        ui::ContextFactory::GetInstance()->SharedMainThreadContextProvider();
+    context_provider_ = context_factory->SharedMainThreadContextProvider();
     gpu::gles2::GLES2Interface* gl = context_provider_->ContextGL();
     GLuint texture = 0;
     gl->GenTextures(1, &texture);
     gl->BindTexture(GL_TEXTURE_2D, texture);
     gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
     gl->TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
     gl->TexImage2D(GL_TEXTURE_2D,
                    0,
@@ skipping 150 matching lines @@
   content_layer.Add(&page_background);
 
   int frames = atoi(command_line->GetSwitchValueASCII("frames").c_str());
   scoped_ptr<BenchCompositorObserver> bench;
 
   if (command_line->HasSwitch("bench-software-scroll")) {
     bench.reset(new SoftwareScrollBench(&page_background,
                                         host->compositor(),
                                         frames));
   } else {
-    bench.reset(new WebGLBench(&page_background,
+    bench.reset(new WebGLBench(context_factory.get(),
+                               &page_background,
                                host->compositor(),
                                frames));
   }
 
 #ifndef NDEBUG
   ui::PrintLayerHierarchy(host->window()->layer(), gfx::Point(100, 100));
 #endif
 
   host->Show();
   base::MessageLoopForUI::current()->Run();
   focus_client.reset();
   host.reset();
 
   return 0;
 }