Give the media context small memory limits (same as compositor).

content/renderer/render_thread_impl.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/renderer/render_thread_impl.h"
 
 #include <algorithm>
 #include <limits>
 #include <map>
 #include <utility>
@@ skipping 388 matching lines @@
   for (size_t i = 0; i < pieces.size(); ++i) {
     unsigned number = 0;
     bool succeed = base::StringToUint(pieces[i], &number);
     DCHECK(succeed);
     vector->push_back(number);
   }
 }
 
 scoped_refptr<ContextProviderCommandBuffer> CreateOffscreenContext(
     scoped_refptr<gpu::GpuChannelHost> gpu_channel_host,
+    const gpu::SharedMemoryLimits& limits,
     command_buffer_metrics::ContextType type,
     int32_t stream_id,
     gpu::GpuStreamPriority stream_priority) {
   DCHECK(gpu_channel_host);
   // This is used to create a few different offscreen contexts:
   // - The shared main thread context (offscreen) used by blink for canvas.
   // - The worker context (offscreen) used for GPU raster and video decoding.
   // This is for an offscreen context, so the default framebuffer doesn't need
   // alpha, depth, stencil, antialiasing.
   gpu::gles2::ContextCreationAttribHelper attributes;
   attributes.alpha_size = -1;
   attributes.depth_size = 0;
   attributes.stencil_size = 0;
   attributes.samples = 0;
   attributes.sample_buffers = 0;
   attributes.bind_generates_resource = false;
   attributes.lose_context_when_out_of_memory = true;
   const bool automatic_flushes = false;
   return make_scoped_refptr(new ContextProviderCommandBuffer(
       std::move(gpu_channel_host), stream_id, stream_priority,
       gpu::kNullSurfaceHandle,
       GURL("chrome://gpu/RenderThreadImpl::CreateOffscreenContext"),
-      gfx::PreferIntegratedGpu, automatic_flushes, gpu::SharedMemoryLimits(),
-      attributes, nullptr, type));
+      gfx::PreferIntegratedGpu, automatic_flushes, limits, attributes, nullptr,
+      type));
 }
 
 }  // namespace
 
 // For measuring memory usage after each task. Behind a command line flag.
 class MemoryObserver : public base::MessageLoop::TaskObserver {
  public:
   MemoryObserver() {}
   ~MemoryObserver() override {}
 
@@ skipping 964 matching lines @@
       }
     }
   }
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
 
   scoped_refptr<gpu::GpuChannelHost> gpu_channel_host =
       EstablishGpuChannelSync(CAUSE_FOR_GPU_LAUNCH_MEDIA_CONTEXT);
   if (!gpu_channel_host)
     return nullptr;
+  // This context is only used to create textures and mailbox them, so
+  // use lower limits than the default.
+  gpu::SharedMemoryLimits limits = gpu::SharedMemoryLimits::ForMailboxContext();
   scoped_refptr<ContextProviderCommandBuffer> media_context_provider =
-      CreateOffscreenContext(
-          gpu_channel_host, command_buffer_metrics::RENDER_WORKER_CONTEXT,
-          gpu::GPU_STREAM_DEFAULT, gpu::GpuStreamPriority::NORMAL);
+      CreateOffscreenContext(gpu_channel_host, limits,
+                             command_buffer_metrics::RENDER_WORKER_CONTEXT,
+                             gpu::GPU_STREAM_DEFAULT,
+                             gpu::GpuStreamPriority::NORMAL);
   if (!media_context_provider->BindToCurrentThread())
     return nullptr;
   media_context_provider->SetupLock();
 
   scoped_refptr<base::SingleThreadTaskRunner> media_task_runner =
       GetMediaThreadTaskRunner();
   const bool enable_video_accelerator =
       !cmd_line->HasSwitch(switches::kDisableAcceleratedVideoDecode);
   const bool enable_gpu_memory_buffer_video_frames =
 #if defined(OS_MACOSX) || defined(OS_LINUX)
@@ skipping 24 matching lines @@
     return shared_main_thread_contexts_;
 
   scoped_refptr<gpu::GpuChannelHost> gpu_channel_host(EstablishGpuChannelSync(
       CAUSE_FOR_GPU_LAUNCH_RENDERER_SHARED_MAIN_THREAD_CONTEXT));
   if (!gpu_channel_host) {
     shared_main_thread_contexts_ = nullptr;
     return nullptr;
   }
 
   shared_main_thread_contexts_ = CreateOffscreenContext(
-      std::move(gpu_channel_host),
+      std::move(gpu_channel_host), gpu::SharedMemoryLimits(),
       command_buffer_metrics::RENDERER_MAINTHREAD_CONTEXT,
       gpu::GPU_STREAM_DEFAULT, gpu::GpuStreamPriority::NORMAL);
   if (!shared_main_thread_contexts_->BindToCurrentThread())
     shared_main_thread_contexts_ = nullptr;
   return shared_main_thread_contexts_;
 }
 
 #if defined(OS_ANDROID)
 
 scoped_refptr<StreamTextureFactory> RenderThreadImpl::GetStreamTexureFactory() {
@@ skipping 485 matching lines @@
     return shared_worker_context_provider_;
   }
 
   int32_t stream_id = gpu::GPU_STREAM_DEFAULT;
   gpu::GpuStreamPriority stream_priority = gpu::GpuStreamPriority::NORMAL;
   if (is_async_worker_context_enabled_) {
     stream_id = gpu_channel_host->GenerateStreamID();
     stream_priority = gpu::GpuStreamPriority::LOW;
   }
 
-  shared_worker_context_provider_ =
-      CreateOffscreenContext(std::move(gpu_channel_host),
-                             command_buffer_metrics::RENDER_WORKER_CONTEXT,
-                             stream_id, stream_priority);
+  shared_worker_context_provider_ = CreateOffscreenContext(
+      std::move(gpu_channel_host), gpu::SharedMemoryLimits(),
+      command_buffer_metrics::RENDER_WORKER_CONTEXT, stream_id,
+      stream_priority);
   if (!shared_worker_context_provider_->BindToCurrentThread())
     shared_worker_context_provider_ = nullptr;
   if (shared_worker_context_provider_)
     shared_worker_context_provider_->SetupLock();
   return shared_worker_context_provider_;
 }
 
 void RenderThreadImpl::SampleGamepads(blink::WebGamepads* data) {
   blink_platform_impl_->sampleGamepads(*data);
 }
@@ skipping 98 matching lines @@
       v8_memory_pressure_level == v8::MemoryPressureLevel::kCritical)
     v8_memory_pressure_level = v8::MemoryPressureLevel::kModerate;
 
   blink::mainThreadIsolate()->MemoryPressureNotification(
       v8_memory_pressure_level);
   blink::MemoryPressureNotificationToWorkerThreadIsolates(
       v8_memory_pressure_level);
 }
 
 }  // namespace content