[cc] Update UIResource test threading

cc/trees/layer_tree_host.cc

 // Copyright 2011 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 "cc/trees/layer_tree_host.h"
 
 #include <algorithm>
+#include <set>
 #include <stack>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "cc/animation/animation_registrar.h"
@@ skipping 1152 matching lines @@
     return;
 
   UIResourceRequest request;
   request.type = UIResourceRequest::UIResourceDelete;
   request.id = uid;
   ui_resource_request_queue_.push_back(request);
   ui_resource_client_map_.erase(uid);
 }
 
 void LayerTreeHost::RecreateUIResources(bool resource_lost) {
+  // Enumerate the resources that will be created when the queue is processed
+  // so that we don't re-create resources unnecessarily.
+  std::set<UIResourceId> already_recreated_resources;

[aelias_OOO_until_Jul13, 2013/09/07 21:34:09]

Hmm, I'm not wholly opposed to having this, but we considered it originally, and
figured it would be a somewhat fake protection against duplicate creation calls
since they could still be sitting in the pending tree when context is lost.  So
we kept this function simple and made sure the impl-side could handle duplicate
creation.  Could you clarify in what way it makes the tests behave more
consistently, is it actually a race or just that the creation counts look more
reasonable?

[ccameron, 2013/09/08 01:54:33]

The behavior that this works around is a strange thing where SingleThreadProxy
will issue two commits after a context lost ... I'm not sure if that is
intentional or not, so I filed a bug against the issue
(http://crbug.com/287250), and I changed the test expectations to differ on
single-versus multi-threaded proxy (explicitly referencing the bug).

+  for (UIResourceRequestQueue::const_iterator iter =
+           ui_resource_request_queue_.begin();
+       iter != ui_resource_request_queue_.end(); ++iter) {
+    const UIResourceRequest& request = *iter;
+    if (request.type == UIResourceRequest::UIResourceCreate)
+      already_recreated_resources.insert(request.id);
+    else if (request.type == UIResourceRequest::UIResourceDelete)
+      already_recreated_resources.erase(request.id);
+  }
   for (UIResourceClientMap::iterator iter = ui_resource_client_map_.begin();
        iter != ui_resource_client_map_.end();
        ++iter) {
     UIResourceId uid = iter->first;
+    if (already_recreated_resources.count(uid))
+      continue;
     UIResourceRequest request;
     request.type = UIResourceRequest::UIResourceCreate;
     request.id = uid;
     request.bitmap = iter->second->GetBitmap(uid, resource_lost);
     DCHECK(request.bitmap.get());
     ui_resource_request_queue_.push_back(request);
   }
 }
 
 }  // namespace cc