Create manager to track OffscreenCanvasSurfaceImpl instances

content/browser/renderer_host/offscreen_canvas_surface_manager.cc

+// Copyright 2016 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/offscreen_canvas_surface_manager.h"
+
+namespace content {
+
+namespace {
+OffscreenCanvasSurfaceManager* g_manager = NULL;
+}
+
+OffscreenCanvasSurfaceManager::OffscreenCanvasSurfaceManager() {}
+
+OffscreenCanvasSurfaceManager::~OffscreenCanvasSurfaceManager() {
+  registered_surface_instances_.clear();
+  registered_compositor_frame_sink_instances_.clear();
+}
+
+OffscreenCanvasSurfaceManager* OffscreenCanvasSurfaceManager::GetInstance() {
+  if (!g_manager) {
+    g_manager = new OffscreenCanvasSurfaceManager();

[dcheng, 2016/11/08 18:30:23]

Let's just use a leaky LazyInstance, unless there's a reason to do otherwise.

(Why do we need to do this cleanup? What breaks if we don't have Terminate()?)

[xlai (Olivia), 2016/11/10 15:45:11]

I'm following the example of ImageTransportFactory where it has a global
singleton and has Terminate() when the browser main thread is shutdown.

The Terminate() must be triggered because it deletes this object and invokes its
destructor to clear the two unordered_map. Note that the two unordered_map
contains weak pointers of Mojo services. In the future, we rely on the weak
pointer to make IPC call and will erase weak pointer if the Mojo service is shut
down. Therefore, in the case when browser main thread is shut down, just before
the mojo IPC service is reset, we must clean up these weak pointers. I take a
look at the template LazyInstance and it does not offer me such an explicit call
to destructor so it's not quite suitable in this case.

[dcheng, 2016/11/11 08:36:40]

I guess I'm missing something still. Don't the objects tracked in the map
unregister themselves on destruction anyway? If they're not destroyed when the
process is exiting, then leaving them in the map doesn't matter. And if they are
destroyed, they'll be removed from the maps anyway?

+  }
+  return g_manager;
+}
+
+void OffscreenCanvasSurfaceManager::Terminate() {
+  if (g_manager) {
+    delete g_manager;
+    g_manager = NULL;
+  }
+}
+
+void OffscreenCanvasSurfaceManager::RegisterOffscreenCanvasSurfaceInstance(
+    int canvas_id,
+    OffscreenCanvasSurfaceImpl* surface_instance) {
+  DCHECK(surface_instance);
+  DCHECK_EQ(registered_surface_instances_.count(canvas_id), 0u);
+  registered_surface_instances_[canvas_id] = surface_instance->GetWeakPtr();
+}
+
+void OffscreenCanvasSurfaceManager::UnregisterOffscreenCanvasSurfaceInstance(
+    int canvas_id) {
+  DCHECK_EQ(registered_surface_instances_.count(canvas_id), 1u);
+  registered_surface_instances_.erase(canvas_id);
+}
+
+void OffscreenCanvasSurfaceManager::RegisterCompositorFrameSinkInstance(
+    int canvas_id,
+    OffscreenCanvasCompositorFrameSink* surface_instance) {
+  DCHECK(surface_instance);
+  DCHECK_EQ(registered_compositor_frame_sink_instances_.count(canvas_id), 0u);
+  registered_compositor_frame_sink_instances_[canvas_id] =
+      surface_instance->GetWeakPtr();
+}
+
+void OffscreenCanvasSurfaceManager::UnregisterCompositorFrameSinkInstance(
+    int canvas_id) {
+  DCHECK_EQ(registered_compositor_frame_sink_instances_.count(canvas_id), 1u);
+  registered_compositor_frame_sink_instances_.erase(canvas_id);
+}
+
+}  // namespace content