aura: Remove CreateOffscreenContext from ui::ContextFactory.

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.
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/i18n/icu_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_split.h"
 #include "base/time/time.h"
+#include "cc/output/context_provider.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/focus_manager.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/test_screen.h"
 #include "ui/aura/window.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/resource/resource_bundle.h"
@@ skipping 151 matching lines @@
 };
 
 // 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)
       : BenchCompositorObserver(max_frames),
         parent_(parent),
         webgl_(ui::LAYER_TEXTURED),
         compositor_(compositor),
-        context_(),
+        context_provider_(),
         texture_(),
         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_ = ui::ContextFactory::GetInstance()->CreateOffscreenContext();
-    context_->makeContextCurrent();
-    texture_ = new WebGLTexture(context_.get(), bounds.size());
-    fbo_ = context_->createFramebuffer();
+    context_provider_ =
+        ui::ContextFactory::GetInstance()->
+        OffscreenContextProviderForMainThread();

[sadrul, 2013/08/13 01:18:17]

I assume this follows any special indentation rule for more-than-two-line
statements (if any).

[danakj, 2013/08/13 01:21:09]

I clang-formatted it now just in case.

+    WebKit::WebGraphicsContext3D* context = context_provider_->Context3d();
+    context->makeContextCurrent();
+    texture_ = new WebGLTexture(context, bounds.size());
+    fbo_ = context->createFramebuffer();
     compositor->AddObserver(this);
     webgl_.SetExternalTexture(texture_.get());
-    context_->bindFramebuffer(GL_FRAMEBUFFER, fbo_);
-    context_->framebufferTexture2D(
+    context->bindFramebuffer(GL_FRAMEBUFFER, fbo_);
+    context->framebufferTexture2D(
         GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
         GL_TEXTURE_2D, texture_->PrepareTexture(), 0);
-    context_->clearColor(0.f, 1.f, 0.f, 1.f);
-    context_->clear(GL_COLOR_BUFFER_BIT);
-    context_->flush();
+    context->clearColor(0.f, 1.f, 0.f, 1.f);
+    context->clear(GL_COLOR_BUFFER_BIT);
+    context->flush();
   }
 
   virtual ~WebGLBench() {
-    context_->makeContextCurrent();
-    context_->deleteFramebuffer(fbo_);
+    context_provider_->Context3d()->makeContextCurrent();
+    context_provider_->Context3d()->deleteFramebuffer(fbo_);
     webgl_.SetExternalTexture(NULL);
     texture_ = NULL;
     compositor_->RemoveObserver(this);
   }
 
   virtual void Draw() OVERRIDE {
     if (do_draw_) {
-      context_->makeContextCurrent();
-      context_->clearColor((frames() % kFrames)*1.0/kFrames, 1.f, 0.f, 1.f);
-      context_->clear(GL_COLOR_BUFFER_BIT);
-      context_->flush();
+      WebKit::WebGraphicsContext3D* context = context_provider_->Context3d();
+      context->makeContextCurrent();
+      context->clearColor((frames() % kFrames)*1.0/kFrames, 1.f, 0.f, 1.f);
+      context->clear(GL_COLOR_BUFFER_BIT);
+      context->flush();
     }
     webgl_.SetExternalTexture(texture_.get());
     webgl_.SchedulePaint(gfx::Rect(webgl_.bounds().size()));
     compositor_->ScheduleDraw();
   }
 
  private:
   Layer* parent_;
   Layer webgl_;
   Compositor* compositor_;
-  scoped_ptr<WebGraphicsContext3D> context_;
+  scoped_refptr<cc::ContextProvider> context_provider_;
   scoped_refptr<WebGLTexture> texture_;
 
   // The FBO that is used to render to the texture.
   unsigned int fbo_;
 
   // Whether or not to draw to the texture every frame.
   bool do_draw_;
 
   DISALLOW_COPY_AND_ASSIGN(WebGLBench);
 };
@@ skipping 94 matching lines @@
   ui::PrintLayerHierarchy(root_window->layer(), gfx::Point(100, 100));
 #endif
 
   root_window->ShowRootWindow();
   base::MessageLoopForUI::current()->Run();
   focus_client.reset();
   root_window.reset();
 
   return 0;
 }