Update from https://crrev.com/308996

gpu/command_buffer/service/valuebuffer_manager.cc

 // Copyright (c) 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 "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/valuebuffer_manager.h"
 
 namespace gpu {
 namespace gles2 {
 
+SubscriptionRefSet::Observer::~Observer() {
+}
+
+SubscriptionRefSet::SubscriptionRefSet() {
+}
+
+SubscriptionRefSet::~SubscriptionRefSet() {
+  // Make sure no valuebuffers are still holding references to targets
+  DCHECK(reference_set_.empty());
+}
+
+void SubscriptionRefSet::AddSubscription(unsigned int target) {
+  RefSet::iterator it = reference_set_.find(target);
+  if (it == reference_set_.end()) {
+    reference_set_.insert(std::make_pair(target, 1));
+    FOR_EACH_OBSERVER(Observer, observers_, OnAddSubscription(target));
+  } else {
+    ++it->second;
+  }
+}
+
+void SubscriptionRefSet::RemoveSubscription(unsigned int target) {
+  RefSet::iterator it = reference_set_.find(target);
+  DCHECK(it != reference_set_.end());
+  if (it->second == 1) {
+    reference_set_.erase(it);
+    FOR_EACH_OBSERVER(Observer, observers_, OnRemoveSubscription(target));
+  } else {
+    --it->second;
+  }
+}
+
+void SubscriptionRefSet::AddObserver(Observer* observer) {
+  observers_.AddObserver(observer);
+}
+
+void SubscriptionRefSet::RemoveObserver(Observer* observer) {
+  observers_.RemoveObserver(observer);
+}
+
 Valuebuffer::Valuebuffer(ValuebufferManager* manager, unsigned int client_id)
     : manager_(manager), client_id_(client_id), has_been_bound_(false) {
   manager_->StartTracking(this);
   active_state_map_ = new ValueStateMap();
 }
 
 Valuebuffer::~Valuebuffer() {
   if (manager_) {
+    for (SubscriptionSet::const_iterator it = subscriptions_.begin();
+        it != subscriptions_.end(); ++it) {
+      manager_->NotifyRemoveSubscription(*it);
+    }
     manager_->StopTracking(this);
     manager_ = NULL;
   }
 }
 
 void Valuebuffer::AddSubscription(unsigned int subscription) {
-  subscriptions_.insert(subscription);
+  if (subscriptions_.find(subscription) == subscriptions_.end()) {
+    subscriptions_.insert(subscription);
+    manager_->NotifyAddSubscription(subscription);
+  }
 }
 
 void Valuebuffer::RemoveSubscription(unsigned int subscription) {
-  subscriptions_.erase(subscription);
+  SubscriptionSet::iterator it = subscriptions_.find(subscription);
+  if (subscriptions_.find(subscription) != subscriptions_.end()) {
+    subscriptions_.erase(it);
+    manager_->NotifyRemoveSubscription(subscription);
+  }
 }
 
 bool Valuebuffer::IsSubscribed(unsigned int subscription) {
   return subscriptions_.find(subscription) != subscriptions_.end();
 }
 
 const ValueState* Valuebuffer::GetState(unsigned int target) const {
   return active_state_map_->GetState(target);
 }
 
 void Valuebuffer::UpdateState(const ValueStateMap* pending_state) {
   DCHECK(pending_state);
   for (SubscriptionSet::const_iterator it = subscriptions_.begin();
        it != subscriptions_.end(); ++it) {
     const ValueState *state = pending_state->GetState(*it);
     if (state != NULL) {
       active_state_map_->UpdateState(*it, *state);
     }
   }
 }
 
-ValuebufferManager::ValuebufferManager(ValueStateMap* state_map)
+ValuebufferManager::ValuebufferManager(SubscriptionRefSet* ref_set,
+                                       ValueStateMap* state_map)
     : valuebuffer_count_(0),
-      pending_state_map_(state_map) {
+      pending_state_map_(state_map),
+      subscription_ref_set_(ref_set) {
 }
 
 ValuebufferManager::~ValuebufferManager() {
   DCHECK(valuebuffer_map_.empty());
   // If this triggers, that means something is keeping a reference to
   // a Valuebuffer belonging to this.
   CHECK_EQ(valuebuffer_count_, 0u);
 }
 
 void ValuebufferManager::Destroy() {
   valuebuffer_map_.clear();
 }
 
 void ValuebufferManager::StartTracking(Valuebuffer* /* valuebuffer */) {
   ++valuebuffer_count_;
 }
 
 void ValuebufferManager::StopTracking(Valuebuffer* /* valuebuffer */) {
   --valuebuffer_count_;
 }
 
+void ValuebufferManager::NotifyAddSubscription(unsigned int target) {
+  subscription_ref_set_->AddSubscription(target);
+}
+void ValuebufferManager::NotifyRemoveSubscription(unsigned int target) {
+  subscription_ref_set_->RemoveSubscription(target);
+}
+
 void ValuebufferManager::CreateValuebuffer(unsigned int client_id) {
   scoped_refptr<Valuebuffer> valuebuffer(new Valuebuffer(this, client_id));
   std::pair<ValuebufferMap::iterator, bool> result =
       valuebuffer_map_.insert(std::make_pair(client_id, valuebuffer));
   DCHECK(result.second);
 }
 
 Valuebuffer* ValuebufferManager::GetValuebuffer(unsigned int client_id) {
   ValuebufferMap::iterator it = valuebuffer_map_.find(client_id);
   return it != valuebuffer_map_.end() ? it->second.get() : NULL;
@@ skipping 17 matching lines @@
   switch (target) {
     case GL_MOUSE_POSITION_CHROMIUM:
       return Program::kUniform2i;
   }
   NOTREACHED() << "Unhandled uniform subscription target " << target;
   return Program::kUniformNone;
 }
 
 }  // namespace gles2
 }  // namespace gpu