Remove WebGLObject maps from WebGLRenderingContextBase and WebGLContextGroup.

third_party/WebKit/Source/modules/webgl/WebGLSharedObject.cpp

 /*
  * Copyright (C) 2011 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 13 matching lines @@
  */
 
 #include "modules/webgl/WebGLSharedObject.h"
 
 #include "modules/webgl/WebGLContextGroup.h"
 #include "modules/webgl/WebGLRenderingContextBase.h"
 
 namespace blink {
 
 WebGLSharedObject::WebGLSharedObject(WebGLRenderingContextBase* context)
-    : WebGLObject(context), m_contextGroup(context->contextGroup()) {}
+    : WebGLObject(context), m_contextGroup(this, context->contextGroup()) {}
 
-WebGLSharedObject::~WebGLSharedObject() {
-  if (m_contextGroup)
-    m_contextGroup->removeObject(this);
+bool WebGLSharedObject::validate(const WebGLContextGroup* contextGroup,
+                                 const WebGLRenderingContextBase*) const {
+  // The contexts and context groups no longer maintain references to all
+  // the objects they ever created, so there's no way to invalidate them
+  // eagerly during context loss. The invalidation is discovered lazily.
+  return contextGroup == m_contextGroup &&
+         cachedNumberOfContextLosses() == contextGroup->numberOfContextLosses();

[Zhenyao Mo, 2016/12/02 18:58:40]

Can you add a comment here saying for WebGL, there is only one context per
context group here? Otherwise the logic is confusing here.

[Ken Russell (switch to Gerrit), 2016/12/02 20:38:49]

There's actually no such assumption in this code, and the logic should be
correct even if there was more than one context. The number of context losses is
a concept per share group. Contexts delegate the reporting of that number to
their share group. Objects record the number of context losses from their share
group at their creation time.

I think we should consider removing the support for shared objects, which was
never exposed to JS, since we're likely to produce a radically new low-level
WebGL which will eliminate the need for this concept. It would make the lifetime
semantics even simpler.

 }
 
-void WebGLSharedObject::detachContextGroup() {
-  detach();
-  if (m_contextGroup) {
-    deleteObject(nullptr);
-    m_contextGroup->removeObject(this);
-    m_contextGroup = nullptr;
-  }
+uint32_t WebGLSharedObject::currentNumberOfContextLosses() const {
+  return m_contextGroup->numberOfContextLosses();
 }
 
 gpu::gles2::GLES2Interface* WebGLSharedObject::getAGLInterface() const {
   return m_contextGroup ? m_contextGroup->getAGLInterface() : nullptr;
 }
 
+DEFINE_TRACE(WebGLSharedObject) {
+  visitor->trace(m_contextGroup);
+  WebGLObject::trace(visitor);
+}
+
+DEFINE_TRACE_WRAPPERS(WebGLSharedObject) {
+  visitor->traceWrappers(m_contextGroup);
+  WebGLObject::traceWrappers(visitor);
+}
+
 }  // namespace blink