Update Crashpad to 8e37886d418dd042c3c7bfadac99214739ee4d98

third_party/crashpad/crashpad/util/thread/worker_thread_test.cc

 // Copyright 2015 The Crashpad Authors. All rights reserved.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //     http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 12 matching lines @@
 namespace {
 
 const uint64_t kNanosecondsPerSecond = static_cast<uint64_t>(1E9);
 
 class WorkDelegate : public WorkerThread::Delegate {
  public:
   WorkDelegate() {}
   ~WorkDelegate() {}
 
   void DoWork(const WorkerThread* thread) override {
-    if (++work_count_ == waiting_for_count_)
-      semaphore_.Signal();
+    if (work_count_ < waiting_for_count_) {
+      if (++work_count_ == waiting_for_count_) {
+        semaphore_.Signal();
+      }
+    }
   }
 
   void SetDesiredWorkCount(int times) {
     waiting_for_count_ = times;
   }
 
   //! \brief Suspends the calling thread until the DoWork() has been called
   //!     the number of times specified by SetDesiredWorkCount().
   void WaitForWorkCount() {
     semaphore_.Wait();
   }
 
   int work_count() const { return work_count_; }
 
  private:
   Semaphore semaphore_{0};
   int work_count_ = 0;
   int waiting_for_count_ = -1;
 
   DISALLOW_COPY_AND_ASSIGN(WorkDelegate);
 };
 
 TEST(WorkerThread, DoWork) {
   WorkDelegate delegate;
   WorkerThread thread(0.05, &delegate);
 
   uint64_t start = ClockMonotonicNanoseconds();
+
   delegate.SetDesiredWorkCount(2);
   thread.Start(0);
   EXPECT_TRUE(thread.is_running());
 
   delegate.WaitForWorkCount();
   thread.Stop();
   EXPECT_FALSE(thread.is_running());
 
   EXPECT_GE(1 * kNanosecondsPerSecond, ClockMonotonicNanoseconds() - start);
 }
@@ skipping 24 matching lines @@
   thread.Start(0);
   delegate.WaitForWorkCount();
   thread.Stop();
   ASSERT_FALSE(thread.is_running());
 }
 
 TEST(WorkerThread, DoWorkNow) {
   WorkDelegate delegate;
   WorkerThread thread(100, &delegate);
 
+  uint64_t start = ClockMonotonicNanoseconds();
+
   delegate.SetDesiredWorkCount(1);
   thread.Start(0);
   EXPECT_TRUE(thread.is_running());
 
-  uint64_t start = ClockMonotonicNanoseconds();
-
   delegate.WaitForWorkCount();
   EXPECT_EQ(1, delegate.work_count());
 
   delegate.SetDesiredWorkCount(2);
   thread.DoWorkNow();
   delegate.WaitForWorkCount();
   thread.Stop();
   EXPECT_EQ(2, delegate.work_count());
 
   EXPECT_GE(100 * kNanosecondsPerSecond, ClockMonotonicNanoseconds() - start);
@@ skipping 15 matching lines @@
 
   EXPECT_GE(100 * kNanosecondsPerSecond, ClockMonotonicNanoseconds() - start);
 
   thread.Stop();
   EXPECT_FALSE(thread.is_running());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace crashpad