Move SharedMemoryLimits out of WebGraphicsContext3DCommandBufferImpl.

content/browser/compositor/gpu_process_transport_factory.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 "content/browser/compositor/gpu_process_transport_factory.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 27 matching lines @@
 #include "content/browser/gpu/gpu_data_manager_impl.h"
 #include "content/browser/gpu/gpu_surface_tracker.h"
 #include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/common/gpu/client/webgraphicscontext3d_command_buffer_impl.h"
 #include "content/common/gpu_process_launch_causes.h"
 #include "content/common/host_shared_bitmap_manager.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
+#include "gpu/command_buffer/client/shared_memory_limits.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/compositor_constants.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/layer.h"
 #include "ui/gfx/geometry/size.h"
 
 #if defined(MOJO_RUNNER_CLIENT)
@@ skipping 55 matching lines @@
   attributes.bind_generates_resource = false;
   attributes.lose_context_when_out_of_memory = true;
 
   bool share_resources = true;
   bool automatic_flushes = false;
 
   GURL url("chrome://gpu/GpuProcessTransportFactory::CreateContextCommon");
   return base::WrapUnique(new content::WebGraphicsContext3DCommandBufferImpl(
       surface_handle, url, gpu_channel_host.get(), attributes,
       gfx::PreferIntegratedGpu, share_resources, automatic_flushes,
-      content::WebGraphicsContext3DCommandBufferImpl::SharedMemoryLimits(),
       nullptr));
 }
 
 }  // namespace
 
 namespace content {
 
 struct GpuProcessTransportFactory::PerCompositorData {
   int surface_id;
   BrowserCompositorOutputSurface* surface;
@@ skipping 166 matching lines @@
 #endif
 
   scoped_refptr<ContextProviderCommandBuffer> context_provider;
   if (create_gpu_output_surface) {
     // Try to reuse existing worker context provider.
     if (shared_worker_context_provider_) {
       bool lost;
       {
         // Note: If context is lost, we delete reference after releasing the
         // lock.
+        cc::ContextProvider::ScopedContextLock(
+            shared_worker_context_provider_.get());
         base::AutoLock lock(*shared_worker_context_provider_->GetLock());
         lost = shared_worker_context_provider_->ContextGL()
                    ->GetGraphicsResetStatusKHR() != GL_NO_ERROR;
       }
       if (lost)
         shared_worker_context_provider_ = nullptr;
     }
 
     scoped_refptr<gpu::GpuChannelHost> gpu_channel_host;
     if (GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor()) {
       // We attempted to do EstablishGpuChannel already, so we just use
       // GetGpuChannel() instead of EstablishGpuChannelSync().
       gpu_channel_host =
           BrowserGpuChannelHostFactory::instance()->GetGpuChannel();
     }
 
     if (!gpu_channel_host) {
       shared_worker_context_provider_ = nullptr;
     } else {
       GpuSurfaceTracker* tracker = GpuSurfaceTracker::Get();
       gpu::SurfaceHandle surface_handle =
           data->surface_id ? tracker->GetSurfaceHandle(data->surface_id)
                            : gpu::kNullSurfaceHandle;
 
       // This context is used for both the browser compositor and the display
       // compositor.
       context_provider = new ContextProviderCommandBuffer(
           CreateContextCommon(gpu_channel_host, surface_handle),
-          DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
+          gpu::SharedMemoryLimits(), DISPLAY_COMPOSITOR_ONSCREEN_CONTEXT);
       if (!context_provider->BindToCurrentThread())
         context_provider = nullptr;
 
       if (!shared_worker_context_provider_) {
         shared_worker_context_provider_ = new ContextProviderCommandBuffer(
             CreateContextCommon(std::move(gpu_channel_host),
                                 gpu::kNullSurfaceHandle),
-            BROWSER_WORKER_CONTEXT);
+            gpu::SharedMemoryLimits(), BROWSER_WORKER_CONTEXT);
         if (shared_worker_context_provider_->BindToCurrentThread())
           shared_worker_context_provider_->SetupLock();
         else
           shared_worker_context_provider_ = nullptr;
       }
     }
 
     bool created_gpu_browser_compositor =
         !!context_provider && !!shared_worker_context_provider_;
 
@@ skipping 12 matching lines @@
     }
   }
 
   std::unique_ptr<BrowserCompositorOutputSurface> surface;
   if (!create_gpu_output_surface) {
     surface = base::WrapUnique(new SoftwareBrowserCompositorOutputSurface(
         CreateSoftwareOutputDevice(compositor.get()),
         compositor->vsync_manager(), compositor->task_runner().get()));
   } else {
     DCHECK(context_provider);
-    ContextProvider::Capabilities capabilities =
-        context_provider->ContextCapabilities();
+    const auto& capabilities = context_provider->ContextCapabilities();
     if (!data->surface_id) {
       surface = base::WrapUnique(new OffscreenBrowserCompositorOutputSurface(
           context_provider, shared_worker_context_provider_,
           compositor->vsync_manager(), compositor->task_runner().get(),
           std::unique_ptr<BrowserCompositorOverlayCandidateValidator>()));
-    } else if (capabilities.gpu.surfaceless) {
+    } else if (capabilities.surfaceless) {
       GLenum target = GL_TEXTURE_2D;
       GLenum format = GL_RGB;
 #if defined(OS_MACOSX)
       target = GL_TEXTURE_RECTANGLE_ARB;
       format = GL_RGBA;
 #endif
       surface =
           base::WrapUnique(new GpuSurfacelessBrowserCompositorOutputSurface(
               context_provider, shared_worker_context_provider_,
               data->surface_id, compositor->vsync_manager(),
@@ skipping 224 matching lines @@
       CAUSE_FOR_GPU_LAUNCH_WEBGRAPHICSCONTEXT3DCOMMANDBUFFERIMPL_INITIALIZE;
   scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(
       BrowserGpuChannelHostFactory::instance()->EstablishGpuChannelSync(cause));
   if (!gpu_channel_host)
     return nullptr;
 
   // We need a separate context from the compositor's so that skia and gl_helper
   // don't step on each other.
   shared_main_thread_contexts_ = new ContextProviderCommandBuffer(
       CreateContextCommon(std::move(gpu_channel_host), gpu::kNullSurfaceHandle),
-      BROWSER_OFFSCREEN_MAINTHREAD_CONTEXT);
+      gpu::SharedMemoryLimits(), BROWSER_OFFSCREEN_MAINTHREAD_CONTEXT);
   shared_main_thread_contexts_->SetLostContextCallback(base::Bind(
       &GpuProcessTransportFactory::OnLostMainThreadSharedContextInsideCallback,
       callback_factory_.GetWeakPtr()));
   if (!shared_main_thread_contexts_->BindToCurrentThread())
     shared_main_thread_contexts_ = nullptr;
   return shared_main_thread_contexts_;
 }
 
 GpuProcessTransportFactory::PerCompositorData*
 GpuProcessTransportFactory::CreatePerCompositorData(
@@ skipping 38 matching lines @@
   FOR_EACH_OBSERVER(ImageTransportFactoryObserver,
                     observer_list_,
                     OnLostResources());
 
   // Kill things that use the shared context before killing the shared context.
   lost_gl_helper.reset();
   lost_shared_main_thread_contexts  = NULL;
 }
 
 }  // namespace content