ozone: Add UiThreadGpu for applications that do UI thread GL

ui/ozone/demo/ozone_demo.cc

 // Copyright 2014 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/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/timer/timer.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #include "ui/ozone/public/surface_ozone_canvas.h"
+#include "ui/ozone/public/ui_thread_gpu.h"
 #include "ui/platform_window/platform_window.h"
 #include "ui/platform_window/platform_window_delegate.h"
 
 const int kTestWindowWidth = 800;
 const int kTestWindowHeight = 600;
 
 const int kFrameDelayMilliseconds = 16;
 
 const int kAnimationSteps = 240;
 
@@ skipping 11 matching lines @@
     // TODO(spang): We should start rendering asynchronously.
     DCHECK_NE(widget_, gfx::kNullAcceleratedWidget)
         << "Widget not available synchronously";
     return widget_;
   }
 
   gfx::Size GetSize() { return platform_window_->GetBounds().size(); }
 
   void Start() {
     if (!CommandLine::ForCurrentProcess()->HasSwitch(kDisableGpu) &&
-        gfx::GLSurface::InitializeOneOff() && InitializeGLSurface()) {
+        gfx::GLSurface::InitializeOneOff() && StartInProcessGpu() &&
+        InitializeGLSurface()) {
       StartAnimationGL();
     } else if (InitializeSoftwareSurface()) {
       StartAnimationSoftware();
     } else {
       LOG(ERROR) << "Failed to create drawing surface";
       Quit();
     }
   }
 
   void Quit() {
@@ skipping 105 matching lines @@
     skia::RefPtr<SkCanvas> canvas = software_surface_->GetCanvas();
 
     SkColor color =
         SkColorSetARGB(0xff, 0, 0xff * fraction, 0xff * (1 - fraction));
 
     canvas->clear(color);
 
     software_surface_->PresentCanvas(gfx::Rect(window_size));
   }
 
+  bool StartInProcessGpu() { return ui_thread_gpu_.Initialize(); }
+
   // Timer for animation.
   base::RepeatingTimer<DemoWindow> timer_;
 
   // Bits for GL rendering.
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_refptr<gfx::GLContext> context_;
 
   // Bits for software rendeirng.
   scoped_ptr<ui::SurfaceOzoneCanvas> software_surface_;
 
   // Window-related state.
   scoped_ptr<ui::PlatformWindow> platform_window_;
   gfx::AcceleratedWidget widget_;
 
+  // Helper for applications that do GL on main thread.
+  ui::UiThreadGpu ui_thread_gpu_;
+
   // Animation state.
   int iteration_;
 
   DISALLOW_COPY_AND_ASSIGN(DemoWindow);
 };
 
 int main(int argc, char** argv) {
   CommandLine::Init(argc, argv);
   base::AtExitManager exit_manager;
 
   // Build UI thread message loop. This is used by platform
   // implementations for event polling & running background tasks.
   base::MessageLoopForUI message_loop;
 
   ui::OzonePlatform::InitializeForUI();
 
   DemoWindow* window = new DemoWindow;
   window->Start();
 
   // Run the message loop until there's nothing left to do.
   // TODO(spang): Should we use QuitClosure instead?
   base::RunLoop run_loop;
   run_loop.RunUntilIdle();
 
   return 0;
 }