[sensors] [mac] Implement ambient light sensor for macOS

device/generic_sensor/one_writer_seqlock_unittest.cc

 // Copyright (c) 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 "content/common/one_writer_seqlock.h"
+#include "device/generic_sensor/one_writer_seqlock.h"
 
 #include <stdlib.h>
 
 #include "base/atomic_ref_count.h"
 #include "base/macros.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 
 // Basic test to make sure that basic operation works correctly.
 
 struct TestData {
   unsigned a, b, c;
 };
 
 class BasicSeqLockTestThread : public PlatformThread::Delegate {
  public:
   BasicSeqLockTestThread() {}
 
-  void Init(
-      content::OneWriterSeqLock* seqlock,
-      TestData* data,
-      base::subtle::Atomic32* ready) {
+  void Init(device::OneWriterSeqLock* seqlock,
+            TestData* data,
+            base::subtle::Atomic32* ready) {
     seqlock_ = seqlock;
     data_ = data;
     ready_ = ready;
   }
   void ThreadMain() override {
     while (AtomicRefCountIsZero(ready_)) {
       PlatformThread::YieldCurrentThread();
     }
 
     for (unsigned i = 0; i < 1000; ++i) {
       TestData copy;
       base::subtle::Atomic32 version;
       do {
         version = seqlock_->ReadBegin();
         copy = *data_;
       } while (seqlock_->ReadRetry(version));
 
       EXPECT_EQ(copy.a + 100, copy.b);
       EXPECT_EQ(copy.c, copy.b + copy.a);
     }
 
     AtomicRefCountDec(ready_);
   }
 
  private:
-  content::OneWriterSeqLock* seqlock_;
+  device::OneWriterSeqLock* seqlock_;
   TestData* data_;
   base::AtomicRefCount* ready_;
 
   DISALLOW_COPY_AND_ASSIGN(BasicSeqLockTestThread);
 };
 
 #if defined(OS_ANDROID)
 #define MAYBE_ManyThreads FLAKY_ManyThreads
 #else
 #define MAYBE_ManyThreads ManyThreads
 #endif
 TEST(OneWriterSeqLockTest, MAYBE_ManyThreads) {
-  content::OneWriterSeqLock seqlock;
-  TestData data = { 0, 0, 0 };
+  device::OneWriterSeqLock seqlock;
+  TestData data = {0, 0, 0};
   base::AtomicRefCount ready = 0;
 
   ANNOTATE_BENIGN_RACE_SIZED(&data, sizeof(data), "Racey reads are discarded");
 
   static const unsigned kNumReaderThreads = 10;
   BasicSeqLockTestThread threads[kNumReaderThreads];
   PlatformThreadHandle handles[kNumReaderThreads];
 
   for (unsigned i = 0; i < kNumReaderThreads; ++i)
     threads[i].Init(&seqlock, &data, &ready);
@@ skipping 14 matching lines @@
 
     if (AtomicRefCountIsZero(&ready))
       break;
   }
 
   for (unsigned i = 0; i < kNumReaderThreads; ++i)
     PlatformThread::Join(handles[i]);
 }
 
 }  // namespace base