Revert "Release GrContext during OnBackgroundCleanup on low end device"

This reverts commit a799e280.

Reason for revert: <Android crashes blocking M-82 crbug.com/1055463>

Original change's description:
> Release GrContext during OnBackgroundCleanup on low end device
> 
> To reduce Gpu memory on low end device, GrContext and associated
> resources should be released. Abandoning GrContext directly results
> in resources associated to theVkDevice becoming lost. It's preferable
> to destroy entire vulkan context during background cleanup and
> re-initialize when chrome is foregrounded.
> 
> Bug: 1048692
> Change-Id: I6bb0740edee72413f0ac083d847d06e4427133ea
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2047828
> Commit-Queue: Kramer Ge <fangzhoug@chromium.org>
> Reviewed-by: Peng Huang <penghuang@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#742815}

TBR=penghuang@chromium.org,fangzhoug@chromium.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: 1048692
Change-Id: Ice1010228ccade56edbb4b3a7b54ba40cbd8dd22
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2070663Reviewed-by: Peng Huang <penghuang@chromium.org>
Commit-Queue: Kramer Ge <fangzhoug@chromium.org>
Cr-Commit-Position: refs/heads/master@{#744050}

components/viz/service/gl/gpu_service_impl.cc

@@ -329,7 +329,6 @@ void GpuServiceImpl::InitializeWithHost(
     owned_sync_point_manager_ = std::make_unique<gpu::SyncPointManager>();
     sync_point_manager = owned_sync_point_manager_.get();
   }
-  sync_point_manager_ = sync_point_manager;
 
   if (!shared_image_manager) {
     // When using real buffers for testing overlay configurations, we need
@@ -344,7 +343,6 @@ void GpuServiceImpl::InitializeWithHost(
     // SharedImageManager.
     DCHECK(!features::ShouldUseRealBuffersForPageFlipTest());
   }
-  shared_image_manager_ = shared_image_manager;
 
   shutdown_event_ = shutdown_event;
   if (!shutdown_event_) {
@@ -355,33 +353,23 @@ void GpuServiceImpl::InitializeWithHost(
   }
 
   scheduler_ = std::make_unique<gpu::Scheduler>(
-      main_runner_, sync_point_manager_, gpu_preferences_);
-
-  default_offscreen_surface_ = std::move(default_offscreen_surface);
-  activity_flags_.emplace(std::move(activity_flags));
+      main_runner_, sync_point_manager, gpu_preferences_);
 
   // Defer creation of the render thread. This is to prevent it from handling
   // IPC messages before the sandbox has been enabled and all other necessary
   // initialization has succeeded.
-  InitializeGpuChannelManager();
-
-  if (watchdog_thread())
-    watchdog_thread()->AddPowerObserver();
-}
-
-void GpuServiceImpl::InitializeGpuChannelManager() {
-  DCHECK(!gpu_channel_manager_ && !media_gpu_channel_manager_);
-
   gpu_channel_manager_ = std::make_unique<gpu::GpuChannelManager>(
       gpu_preferences_, this, watchdog_thread_.get(), main_runner_, io_runner_,
-      scheduler_.get(), sync_point_manager_, shared_image_manager_,
+      scheduler_.get(), sync_point_manager, shared_image_manager,
       gpu_memory_buffer_factory_.get(), gpu_feature_info_,
-      &activity_flags_.value(), default_offscreen_surface_,
+      std::move(activity_flags), std::move(default_offscreen_surface),
       image_decode_accelerator_worker_.get(), vulkan_context_provider(),
       metal_context_provider_.get(), dawn_context_provider());
 
-  media_gpu_channel_manager_ = std::make_unique<media::MediaGpuChannelManager>(
-      gpu_channel_manager_.get());
+  media_gpu_channel_manager_.reset(
+      new media::MediaGpuChannelManager(gpu_channel_manager_.get()));
+  if (watchdog_thread())
+    watchdog_thread()->AddPowerObserver();
 }
 
 void GpuServiceImpl::Bind(
@@ -926,23 +914,9 @@ void GpuServiceImpl::OnBackgroundCleanup() {
   }
   DVLOG(1) << "GPU: Performing background cleanup";
   gpu_channel_manager_->OnBackgroundCleanup();
-
-  if (features::IsUsingSkiaRenderer()) {
-    // Release context providers and related on low-end device to save memory.
-    gpu_memory_buffer_factory_.reset();
-#if BUILDFLAG(ENABLE_VULKAN)
-    vulkan_context_provider_.reset();
-#endif
-#if BUILDFLAG(SKIA_USE_DAWN)
-    dawn_context_provider_.reset();
-#endif
-    gpu_channel_manager_.reset();
-    media_gpu_channel_manager_.reset();
-  }
-
-#else   // defined(OS_ANDROID)
+#else
   NOTREACHED();
-#endif  // !defined(OS_ANDROID)
+#endif
 }
 
 void GpuServiceImpl::OnBackgrounded() {
@@ -960,54 +934,8 @@ void GpuServiceImpl::OnBackgroundedOnMainThread() {
 }
 
 void GpuServiceImpl::OnForegrounded() {
-  DCHECK(io_runner_->BelongsToCurrentThread());
   if (watchdog_thread_)
     watchdog_thread_->OnForegrounded();
-
-#if defined(OS_ANDROID)
-  if (features::IsUsingSkiaRenderer()) {
-    main_runner_->PostTask(
-        FROM_HERE,
-        base::BindOnce(&GpuServiceImpl::OnForegroundedOnMainThread, weak_ptr_));
-  }
-#endif  // defined(OS_ANDROID)
-}
-
-void GpuServiceImpl::OnForegroundedOnMainThread() {
-#if defined(OS_ANDROID)
-  if (gpu_channel_manager())
-    return;
-  DCHECK(features::IsUsingSkiaRenderer());
-
-#if BUILDFLAG(ENABLE_VULKAN)
-  if (vulkan_implementation_) {
-    size_t max_resource_cache_bytes;
-    size_t max_glyph_cache_texture_bytes;
-    gpu::DetermineGrCacheLimitsFromAvailableMemory(
-        &max_resource_cache_bytes, &max_glyph_cache_texture_bytes);
-    GrContextOptions context_options;
-    context_options.fGlyphCacheTextureMaximumBytes =
-        max_glyph_cache_texture_bytes;
-    if (gpu_preferences_.force_max_texture_size) {
-      context_options.fMaxTextureSizeOverride =
-          gpu_preferences_.force_max_texture_size;
-    }
-    vulkan_context_provider_ = VulkanInProcessContextProvider::Create(
-        vulkan_implementation_, context_options);
-  }
-#endif  // BUILDFLAG(ENABLE_VULKAN)
-
-#if BUILDFLAG(SKIA_USE_DAWN)
-  if (gpu_preferences_.gr_context_type == gpu::GrContextType::kDawn) {
-    dawn_context_provider_ = DawnContextProvider::Create();
-  }
-#endif  // BUILDFLAG(SKIA_USE_DAWN)
-
-  gpu_memory_buffer_factory_ =
-      gpu::GpuMemoryBufferFactory::CreateNativeType(vulkan_context_provider());
-
-  InitializeGpuChannelManager();
-#endif  // defined(OS_ANDROID)
 }
 
 #if !defined(OS_ANDROID)

components/viz/service/gl/gpu_service_impl.h

@@ -313,10 +313,8 @@ class VIZ_SERVICE_EXPORT GpuServiceImpl : public gpu::GpuChannelManagerDelegate,
 #endif  // defined(OS_CHROMEOS)
 
   void RequestHDRStatusOnMainThread(RequestHDRStatusCallback callback);
-  void InitializeGpuChannelManager();
 
   void OnBackgroundedOnMainThread();
-  void OnForegroundedOnMainThread();
 
   // Ensure that all peak memory tracking occurs on the main thread as all
   // MemoryTracker are created on that thread. All requests made before
@@ -419,12 +417,6 @@ class VIZ_SERVICE_EXPORT GpuServiceImpl : public gpu::GpuChannelManagerDelegate,
   // Display compositor contexts that don't have a corresponding GPU channel.
   base::ObserverList<gpu::DisplayContext>::Unchecked display_contexts_;
 
-  // Cached resources for recreating |gpu_channel_manager_|.
-  base::Optional<gpu::GpuProcessActivityFlags> activity_flags_;
-  scoped_refptr<gl::GLSurface> default_offscreen_surface_;
-  gpu::SyncPointManager* sync_point_manager_;
-  gpu::SharedImageManager* shared_image_manager_;
-
   base::WeakPtr<GpuServiceImpl> weak_ptr_;
   base::WeakPtrFactory<GpuServiceImpl> weak_ptr_factory_{this};
 

gpu/ipc/service/gpu_channel_manager.cc

@@ -145,7 +145,7 @@ GpuChannelManager::GpuChannelManager(
     SharedImageManager* shared_image_manager,
     GpuMemoryBufferFactory* gpu_memory_buffer_factory,
     const GpuFeatureInfo& gpu_feature_info,
-    GpuProcessActivityFlags* const activity_flags,
+    GpuProcessActivityFlags activity_flags,
     scoped_refptr<gl::GLSurface> default_offscreen_surface,
     ImageDecodeAcceleratorWorker* image_decode_accelerator_worker,
     viz::VulkanContextProvider* vulkan_context_provider,
@@ -170,7 +170,7 @@ GpuChannelManager::GpuChannelManager(
       discardable_manager_(gpu_preferences_),
       passthrough_discardable_manager_(gpu_preferences_),
       image_decode_accelerator_worker_(image_decode_accelerator_worker),
-      activity_flags_(activity_flags),
+      activity_flags_(std::move(activity_flags)),
       memory_pressure_listener_(
           base::BindRepeating(&GpuChannelManager::HandleMemoryPressure,
                               base::Unretained(this))),
@@ -199,10 +199,7 @@ GpuChannelManager::~GpuChannelManager() {
   gpu_channels.clear();
 
   if (default_offscreen_surface_.get()) {
-    // GpuChannelManager may be temporarily destructed when chrome is
-    // backgrounded on low end device, so don't call destroy.
-    if (default_offscreen_surface_->HasOneRef())
-      default_offscreen_surface_->Destroy();
+    default_offscreen_surface_->Destroy();
     default_offscreen_surface_ = nullptr;
   }
 
@@ -234,7 +231,7 @@ gles2::ProgramCache* GpuChannelManager::program_cache() {
       program_cache_.reset(new gles2::MemoryProgramCache(
           gpu_preferences_.gpu_program_cache_size, disable_disk_cache,
           workarounds.disable_program_caching_for_transform_feedback,
-          activity_flags_));
+          &activity_flags_));
     }
   }
   return program_cache_.get();
@@ -567,7 +564,7 @@ scoped_refptr<SharedContextState> GpuChannelManager::GetSharedContextState(
     }
     shared_context_state_->InitializeGrContext(
         gpu_preferences_, gpu_driver_bug_workarounds_, gr_shader_cache(),
-        activity_flags_, watchdog_);
+        &activity_flags_, watchdog_);
   }
 
   gr_cache_controller_.emplace(shared_context_state_.get(), task_runner_);

gpu/ipc/service/gpu_channel_manager.h

@@ -79,7 +79,7 @@ class GPU_IPC_SERVICE_EXPORT GpuChannelManager
       SharedImageManager* shared_image_manager,
       GpuMemoryBufferFactory* gpu_memory_buffer_factory,
       const GpuFeatureInfo& gpu_feature_info,
-      GpuProcessActivityFlags* const activity_flags,
+      GpuProcessActivityFlags activity_flags,
       scoped_refptr<gl::GLSurface> default_offscreen_surface,
       ImageDecodeAcceleratorWorker* image_decode_accelerator_worker,
       viz::VulkanContextProvider* vulkan_context_provider = nullptr,
@@ -270,7 +270,7 @@ class GPU_IPC_SERVICE_EXPORT GpuChannelManager
 
   // Flags which indicate GPU process activity. Read by the browser process
   // on GPU process crash.
-  GpuProcessActivityFlags* const activity_flags_;
+  GpuProcessActivityFlags activity_flags_;
 
   base::MemoryPressureListener memory_pressure_listener_;
 

gpu/ipc/service/gpu_channel_test_common.cc

@@ -90,7 +90,7 @@ GpuChannelTestCommon::GpuChannelTestCommon(
       task_runner_.get(), io_task_runner_.get(), scheduler_.get(),
       sync_point_manager_.get(), shared_image_manager_.get(),
       nullptr, /* gpu_memory_buffer_factory */
-      std::move(feature_info), &activity_flags_,
+      std::move(feature_info), GpuProcessActivityFlags(),
       gl::init::CreateOffscreenGLSurface(gfx::Size()),
       nullptr /* image_decode_accelerator_worker */));
 }

gpu/ipc/service/gpu_channel_test_common.h

@@ -10,7 +10,6 @@
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/unsafe_shared_memory_region.h"
-#include "gpu/command_buffer/common/activity_flags.h"
 #include "ipc/ipc_test_sink.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -65,7 +64,6 @@ class GpuChannelTestCommon : public testing::Test {
   std::unique_ptr<Scheduler> scheduler_;
   std::unique_ptr<TestGpuChannelManagerDelegate> channel_manager_delegate_;
   std::unique_ptr<GpuChannelManager> channel_manager_;
-  GpuProcessActivityFlags activity_flags_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuChannelTestCommon);
 };