TaskScheduler: Avoid Sequence refcount bump in GetWork()

base/task_scheduler/sequence_sort_key_unittest.cc

Index: base/task_scheduler/sequence_sort_key_unittest.cc
diff --git a/base/task_scheduler/sequence_sort_key_unittest.cc b/base/task_scheduler/sequence_sort_key_unittest.cc
index 5c6c917294b83fd27cc3b2bd32b8ab6c148a1822..b9e0aa7c02ea67aa732d5614aaba6d9aa2f1ded7 100644
--- a/base/task_scheduler/sequence_sort_key_unittest.cc
+++ b/base/task_scheduler/sequence_sort_key_unittest.cc
@@ -125,5 +125,62 @@ TEST(TaskSchedulerSequenceSortKeyTest, OperatorGreaterThan) {
   EXPECT_FALSE(key_f > key_f);
 }
 
+TEST(TaskSchedulerSequenceSortKeyTest, OperatorEqualAndNotEqual) {
+  SequenceSortKey key_a(TaskPriority::USER_BLOCKING,
+                        TimeTicks::FromInternalValue(1000));
+  SequenceSortKey key_b(TaskPriority::USER_BLOCKING,
+                        TimeTicks::FromInternalValue(2000));
+  SequenceSortKey key_c(TaskPriority::USER_VISIBLE,
+                        TimeTicks::FromInternalValue(1000));
+  SequenceSortKey key_d(TaskPriority::USER_VISIBLE,
+                        TimeTicks::FromInternalValue(2000));
+  SequenceSortKey key_e(TaskPriority::BACKGROUND,
+                        TimeTicks::FromInternalValue(1000));
+  SequenceSortKey key_f(TaskPriority::BACKGROUND,
+                        TimeTicks::FromInternalValue(2000));
+
+  EXPECT_EQ(key_a, key_a);

[fdoray, 2016/04/28 14:32:29]

This test will succeed if operator== and operator!= always return true. You
should test operator== and operator!= separately.

TEST(... OperatorEqual) {
  EXPECT_EQ(key_a, key_a);
  EXPECT_FALSE(key_b == key_a);
  ...
}

TEST(..., OperatorNotEqual) {
  EXPECT_FALSE(key_a != key_a); 
  EXPECT_NE(key_b, key_a);
  ...
}

[gab, 2016/04/28 15:36:55]

Good catch, done :-)

+  EXPECT_NE(key_b, key_a);
+  EXPECT_NE(key_c, key_a);
+  EXPECT_NE(key_d, key_a);
+  EXPECT_NE(key_e, key_a);
+  EXPECT_NE(key_f, key_a);
+
+  EXPECT_NE(key_a, key_b);
+  EXPECT_EQ(key_b, key_b);
+  EXPECT_NE(key_c, key_b);
+  EXPECT_NE(key_d, key_b);
+  EXPECT_NE(key_e, key_b);
+  EXPECT_NE(key_f, key_b);
+
+  EXPECT_NE(key_a, key_c);
+  EXPECT_NE(key_b, key_c);
+  EXPECT_EQ(key_c, key_c);
+  EXPECT_NE(key_d, key_c);
+  EXPECT_NE(key_e, key_c);
+  EXPECT_NE(key_f, key_c);
+
+  EXPECT_NE(key_a, key_d);
+  EXPECT_NE(key_b, key_d);
+  EXPECT_NE(key_c, key_d);
+  EXPECT_EQ(key_d, key_d);
+  EXPECT_NE(key_e, key_d);
+  EXPECT_NE(key_f, key_d);
+
+  EXPECT_NE(key_a, key_e);
+  EXPECT_NE(key_b, key_e);
+  EXPECT_NE(key_c, key_e);
+  EXPECT_NE(key_d, key_e);
+  EXPECT_EQ(key_e, key_e);
+  EXPECT_NE(key_f, key_e);
+
+  EXPECT_NE(key_a, key_f);
+  EXPECT_NE(key_b, key_f);
+  EXPECT_NE(key_c, key_f);
+  EXPECT_NE(key_d, key_f);
+  EXPECT_NE(key_e, key_f);
+  EXPECT_EQ(key_f, key_f);
+}
+
 }  // namespace internal
 }  // namespace base