cc: Route offscreen context creation for compositor to the browser.

content/browser/renderer_host/image_transport_factory.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 "content/browser/renderer_host/image_transport_factory.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/bind.h"
@@ skipping 13 matching lines @@
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/gpu/gpu_process_launch_causes.h"
 #include "content/common/webkitplatformsupport_impl.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/ipc/command_buffer_proxy.h"
 #include "third_party/WebKit/Source/Platform/chromium/public/WebGraphicsContext3D.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/khronos/GLES2/gl2ext.h"
+#include "third_party/skia/include/gpu/GrContext.h"
+#include "third_party/skia/include/gpu/gl/GrGLInterface.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/compositor_setup.h"
 #include "ui/compositor/test_web_graphics_context_3d.h"
 #include "ui/gfx/native_widget_types.h"
 #include "ui/gfx/size.h"
 
 #if defined(OS_WIN)
 #include "ui/surface/accelerated_surface_win.h"
 #endif
 
@@ skipping 315 matching lines @@
   scoped_refptr<BrowserCompositorOutputSurfaceProxy> output_surface_proxy_;
 };
 
 void BrowserCompositorOutputSurfaceProxy::OnUpdateVSyncParameters(
     int surface_id, base::TimeTicks timebase, base::TimeDelta interval) {
   BrowserCompositorOutputSurface* surface = surface_map_.Lookup(surface_id);
   if (surface)
     surface->OnUpdateVSyncParameters(timebase, interval);
 }
 
+// TODO(danakj): Go directly to GPU process instead of through WGC3D.
+class GrContextMemoryManager
+    : public WebKit::WebGraphicsContext3D::
+          WebGraphicsMemoryAllocationChangedCallbackCHROMIUM {
+ public:
+  GrContextMemoryManager(
+      WebKit::WebGraphicsContext3D* context3d, GrContext* gr_context)
+      : context3d_(context3d),
+        gr_context_(gr_context) {
+
+    gr_context_->setTextureCacheLimits(
+        kMaxGaneshTextureCacheCount, kMaxGaneshTextureCacheBytes);
+    context3d_->setMemoryAllocationChangedCallbackCHROMIUM(this);
+  }
+  ~GrContextMemoryManager() {
+    context3d_->setMemoryAllocationChangedCallbackCHROMIUM(NULL);
+  }
+
+  virtual void onMemoryAllocationChanged(
+      WebKit::WebGraphicsMemoryAllocation allocation) OVERRIDE {
+    if (!gr_context_)
+      return;
+
+    if (!allocation.gpuResourceSizeInBytes) {
+      gr_context_->freeGpuResources();
+      gr_context_->setTextureCacheLimits(0, 0);
+    } else {
+      gr_context_->setTextureCacheLimits(
+          kMaxGaneshTextureCacheCount, kMaxGaneshTextureCacheBytes);
+    }
+  }
+
+ private:
+  // The limit of the number of textures we hold in the GrContext's
+  // bitmap->texture cache.
+  static const int kMaxGaneshTextureCacheCount = 2048;
+  // The limit of the bytes allocated toward textures in the GrContext's
+  // bitmap->texture cache.
+  static const size_t kMaxGaneshTextureCacheBytes = 96 * 1024 * 1024;
+
+  WebKit::WebGraphicsContext3D* context3d_;
+  GrContext* gr_context_;
+};
+
 class GpuProcessTransportFactory
     : public ui::ContextFactory,
       public ImageTransportFactory,
       public WebKit::WebGraphicsContext3D::WebGraphicsContextLostCallback {
  public:
   GpuProcessTransportFactory()
       : ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {
     output_surface_proxy_ = new BrowserCompositorOutputSurfaceProxy();
   }
 
@@ skipping 14 matching lines @@
       data = CreatePerCompositorData(compositor);
     WebGraphicsContext3DCommandBufferImpl* context =
         CreateContextCommon(data->swap_client->AsWeakPtr(),
                             data->surface_id);
     return new BrowserCompositorOutputSurface(
         context,
         per_compositor_data_[compositor]->surface_id,
         output_surface_proxy_);
   }
 
+  WebKit::WebGraphicsContext3D* CreateOrGetOffscreenSkiaContextForMainThread() {
+    CreateOrGetOffscreenContextCommon(
+        &offscreen_skia_context_main_thread,
+        &offscreen_skia_gr_context_main_thread,
+        &offscreen_skia_gr_context_memory_manager_main_thread);
+    return offscreen_skia_context_main_thread.get();
+  }
+
+  WebKit::WebGraphicsContext3D*
+      CreateOrGetOffscreenSkiaContextForCompositorThread() {
+    CreateOrGetOffscreenContextCommon(
+        &offscreen_skia_context_compositor_thread,
+        &offscreen_skia_gr_context_compositor_thread,
+        &offscreen_skia_gr_context_memory_manager_compositor_thread);
+    return offscreen_skia_context_compositor_thread.get();
+  }
+
+  GrContext* CreateOrGetOffscreenSkiaGrContextForMainThread() {
+    CreateOrGetOffscreenSkiaContextForMainThread();
+    CreateOrGetGrContextCommon(
+          offscreen_skia_context_main_thread.get(),
+          &offscreen_skia_gr_context_main_thread,
+          &offscreen_skia_gr_context_memory_manager_main_thread);
+    return offscreen_skia_gr_context_main_thread.get();
+  }
+
+  GrContext* CreateOrGetOffscreenSkiaGrContextForCompositorThread() {
+    CreateOrGetOffscreenSkiaContextForCompositorThread();
+    CreateOrGetGrContextCommon(
+          offscreen_skia_context_compositor_thread.get(),
+          &offscreen_skia_gr_context_compositor_thread,
+          &offscreen_skia_gr_context_memory_manager_compositor_thread);
+    return offscreen_skia_gr_context_compositor_thread.get();
+  }
+
   virtual void RemoveCompositor(ui::Compositor* compositor) OVERRIDE {
     PerCompositorDataMap::iterator it = per_compositor_data_.find(compositor);
     if (it == per_compositor_data_.end())
       return;
     PerCompositorData* data = it->second;
     DCHECK(data);
     GpuSurfaceTracker::Get()->RemoveSurface(data->surface_id);
     delete data;
     per_compositor_data_.erase(it);
     if (per_compositor_data_.empty()) {
@@ skipping 140 matching lines @@
             factory,
             swap_client));
     if (!context->Initialize(
         attrs,
         false,
         CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE))
       return NULL;
     return context.release();
   }
 
+  void CreateOrGetOffscreenContextCommon(
+      scoped_ptr<WebKit::WebGraphicsContext3D>* context3d,
+      skia::RefPtr<GrContext>* gr_context,
+      scoped_ptr<GrContextMemoryManager>* gr_context_memory_manager) {
+    if ((*context3d)) {
+      if (!(*context3d)->makeContextCurrent() ||
+          (*context3d)->getGraphicsResetStatusARB()) {
+        gr_context_memory_manager->reset();
+        if ((*gr_context))
+          (*gr_context)->contextDestroyed();
+        gr_context->clear();
+        context3d->reset();
+      }
+    }
+
+    if (!(*context3d))
+      (*context3d) = make_scoped_ptr(CreateOffscreenContext());

[piman, 2013/02/05 22:42:48]

nit: context3d->reset(CreateOffscreenContext()) is shorter...

[danakj, 2013/02/05 22:56:00]

Done.

+  }
+
+  void CreateOrGetGrContextCommon(
+      WebKit::WebGraphicsContext3D* context3d,
+      skia::RefPtr<GrContext>* gr_context,
+      scoped_ptr<GrContextMemoryManager>* gr_context_memory_manager) {
+    if (!context3d)
+      return;
+    if (*gr_context)
+      return;
+
+    skia::RefPtr<GrGLInterface> interface = skia::AdoptRef(
+        context3d->createGrGLInterface());
+    *gr_context = skia::AdoptRef(GrContext::Create(
+        kOpenGL_Shaders_GrEngine,
+        reinterpret_cast<GrPlatform3DContext>(interface.get())));

[piman, 2013/02/05 22:42:48]

/cry on the reinterpret_cast

[danakj, 2013/02/05 22:56:00]

Ya... more incoming as well :X

+
+    if (*gr_context) {
+      *gr_context_memory_manager = make_scoped_ptr(new GrContextMemoryManager(

[piman, 2013/02/05 22:42:48]

nit: can also use reset(...) here

[danakj, 2013/02/05 22:56:00]

Done.

+          context3d, gr_context->get()));
+    }
+  }
+
   void CreateSharedContextLazy() {
     if (shared_context_.get())
       return;
 
     shared_context_.reset(CreateOffscreenContext());
     if (!shared_context_.get()) {
       // If we can't recreate contexts, we won't be able to show the UI. Better
       // crash at this point.
       LOG(FATAL) << "Failed to initialize UI shared context.";
     }
@@ skipping 18 matching lines @@
   }
 
   typedef std::map<ui::Compositor*, PerCompositorData*> PerCompositorDataMap;
   PerCompositorDataMap per_compositor_data_;
   scoped_ptr<WebGraphicsContext3DCommandBufferImpl> shared_context_;
   scoped_ptr<GLHelper> gl_helper_;
   ObserverList<ImageTransportFactoryObserver> observer_list_;
   base::WeakPtrFactory<GpuProcessTransportFactory> callback_factory_;
   scoped_refptr<BrowserCompositorOutputSurfaceProxy> output_surface_proxy_;
 
+  // Per-process data.
+  scoped_ptr<WebKit::WebGraphicsContext3D> offscreen_skia_context_main_thread;

[piman, 2013/02/05 22:42:48]

Could we reuse the shared_context_ for the main thread? They're costly, it's
worth saving.

[danakj, 2013/02/05 22:56:00]

I don't know, it looks like something that is created once per compositor, not
once per process? I didn't understand what it's purpose was. Can you enlighten?

+  scoped_ptr<WebKit::WebGraphicsContext3D>
+      offscreen_skia_context_compositor_thread;
+  skia::RefPtr<GrContext> offscreen_skia_gr_context_main_thread;
+  skia::RefPtr<GrContext> offscreen_skia_gr_context_compositor_thread;
+  scoped_ptr<GrContextMemoryManager>
+      offscreen_skia_gr_context_memory_manager_main_thread;
+  scoped_ptr<GrContextMemoryManager>
+      offscreen_skia_gr_context_memory_manager_compositor_thread;
+
   DISALLOW_COPY_AND_ASSIGN(GpuProcessTransportFactory);
 };
 
 void CompositorSwapClient::OnLostContext() {
   factory_->OnLostContext(compositor_);
   // Note: previous line destroyed this. Don't access members from now on.
 }
 
 WebKit::WebGraphicsContext3D* CreateTestContext() {
   ui::TestWebGraphicsContext3D* test_context =
@@ skipping 26 matching lines @@
   delete g_factory;
   g_factory = NULL;
 }
 
 // static
 ImageTransportFactory* ImageTransportFactory::GetInstance() {
   return g_factory;
 }
 
 }  // namespace content