cc: Only create compositor context once.

content/renderer/gpu/render_widget_compositor.cc

 // Copyright (c) 2013 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 "content/renderer/gpu/render_widget_compositor.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/synchronization/lock.h"
@@ skipping 452 matching lines @@
 scoped_refptr<cc::ContextProvider>
 RenderWidgetCompositor::OffscreenContextProviderForMainThread() {
   if (!contexts_main_thread_)
     contexts_main_thread_ = new MainThreadContextProvider;
   return contexts_main_thread_;
 }
 
 class RenderWidgetCompositor::CompositorThreadContextProvider
     : public cc::ContextProvider {
  public:
-  CompositorThreadContextProvider() : destroyed_(false) {}
+  CompositorThreadContextProvider() : initialized_(false), destroyed_(false) {}
 
   virtual bool InitializeOnMainThread() OVERRIDE {
-    return WebKit::WebSharedGraphicsContext3D::createCompositorThreadContext();
+    if (!initialized_) {
+      initialized_ =
+          WebKit::WebSharedGraphicsContext3D::createCompositorThreadContext();
+    }
+    return initialized_;
   }
   virtual bool BindToCurrentThread() OVERRIDE {
     return Context3d()->makeContextCurrent();
   }
 
   virtual WebKit::WebGraphicsContext3D* Context3d() OVERRIDE {
     return WebKit::WebSharedGraphicsContext3D::compositorThreadContext();
   }
   virtual class GrContext* GrContext() OVERRIDE {
     return WebKit::WebSharedGraphicsContext3D::compositorThreadGrContext();
   }
 
   virtual void VerifyContexts() OVERRIDE {
     if (Context3d() && !Context3d()->isContextLost())
       return;
     base::AutoLock lock(destroyed_lock_);
     destroyed_ = true;
   }
   bool DestroyedOnMainThread() {
     base::AutoLock lock(destroyed_lock_);
     return destroyed_;
   }
 
  protected:
   virtual ~CompositorThreadContextProvider() {}
 
  private:
+  bool initialized_;
+
   base::Lock destroyed_lock_;
   bool destroyed_;
 };
 
 scoped_refptr<cc::ContextProvider>
 RenderWidgetCompositor::OffscreenContextProviderForCompositorThread() {
   if (!contexts_compositor_thread_ ||
       contexts_compositor_thread_->DestroyedOnMainThread())
     contexts_compositor_thread_ = new CompositorThreadContextProvider;
   return contexts_compositor_thread_;
 }
 
 }  // namespace content