Replace source pointer in cc::CopyOutputRequest with a base::UnguessableToken

cc/layers/layer_unittest.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/layers/layer.h"
 
 #include <stddef.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 66 matching lines @@
       child->GetLayerTree()->LayerNeedsPushPropertiesForTesting(child.get())); \
   EXPECT_FALSE(grand_child->subtree_property_changed());                       \
   EXPECT_FALSE(                                                                \
       grand_child->GetLayerTree()->LayerNeedsPushPropertiesForTesting(         \
           grand_child.get()));
 
 namespace cc {
 
 namespace {
 
+static auto kArbitrarySourceId1 =
+    base::UnguessableToken::Deserialize(0xdead, 0xbeef);
+static auto kArbitrarySourceId2 =
+    base::UnguessableToken::Deserialize(0xdead, 0xbee0);

[vmpstr, 2017/01/27 19:41:25]

I think you mean 0xdead 0xf00d :P (jk)

+
 class MockLayerTree : public LayerTree {
  public:
   MockLayerTree(LayerTreeHostInProcess::InitParams* params,
                 LayerTreeHost* layer_tree_host)
       : LayerTree(params->mutator_host, layer_tree_host) {}
   ~MockLayerTree() override {}
 
   MOCK_METHOD0(SetNeedsFullTreeSync, void());
 };
 
@@ skipping 1242 matching lines @@
   EXPECT_EQ(0, result_count);
 
   // When the layer is destroyed, expect both requests to be aborted.
   layer = nullptr;
   EXPECT_EQ(2, result_count);
 
   layer = Layer::Create();
   result_count = 0;
 
   // Create identical requests, but this time the source is being set.  Expect
-  // the first request from |this| source aborts immediately when the second
-  // request from |this| source is made.
+  // the first request using |kArbitrarySourceId1| aborts immediately when
+  // the second request using |kArbitrarySourceId1| is made.
   int did_receive_first_result_from_this_source = 0;
   request = CopyOutputRequest::CreateRequest(base::Bind(
       &ReceiveCopyOutputResult, &did_receive_first_result_from_this_source));
-  request->set_source(this);
+  request->set_source(kArbitrarySourceId1);
   layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, did_receive_first_result_from_this_source);
   // Make a request from a different source.
   int did_receive_result_from_different_source = 0;
   request = CopyOutputRequest::CreateRequest(base::Bind(
       &ReceiveCopyOutputResult, &did_receive_result_from_different_source));
-  request->set_source(reinterpret_cast<void*>(0xdeadbee0));
+  request->set_source(kArbitrarySourceId2);
   layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, did_receive_result_from_different_source);
   // Make a request without specifying the source.
   int did_receive_result_from_anonymous_source = 0;
   request = CopyOutputRequest::CreateRequest(base::Bind(
       &ReceiveCopyOutputResult, &did_receive_result_from_anonymous_source));
   layer->RequestCopyOfOutput(std::move(request));
   EXPECT_EQ(0, did_receive_result_from_anonymous_source);
-  // Make the second request from |this| source.
+  // Make the second request from |kArbitrarySourceId1|.
   int did_receive_second_result_from_this_source = 0;
   request = CopyOutputRequest::CreateRequest(base::Bind(
       &ReceiveCopyOutputResult, &did_receive_second_result_from_this_source));
-  request->set_source(this);
+  request->set_source(kArbitrarySourceId1);
   layer->RequestCopyOfOutput(
       std::move(request));  // First request to be aborted.
   EXPECT_EQ(1, did_receive_first_result_from_this_source);
   EXPECT_EQ(0, did_receive_result_from_different_source);
   EXPECT_EQ(0, did_receive_result_from_anonymous_source);
   EXPECT_EQ(0, did_receive_second_result_from_this_source);
 
   // When the layer is destroyed, the other three requests should be aborted.
   layer = nullptr;
   EXPECT_EQ(1, did_receive_first_result_from_this_source);
@@ skipping 41 matching lines @@
   EXPECT_EQ(MutableProperty::kNone, impl_layer->mutable_properties());
 
   test_layer->PushPropertiesTo(impl_layer.get());
 
   EXPECT_EQ(ElementId(2, 0), impl_layer->element_id());
   EXPECT_EQ(MutableProperty::kTransform, impl_layer->mutable_properties());
 }
 
 }  // namespace
 }  // namespace cc