Fix race condition in DataFetcherSharedMemoryBase

content/browser/device_orientation/data_fetcher_shared_memory_base.cc

 // Copyright 2013 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/browser/device_orientation/data_fetcher_shared_memory_base.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/threading/thread.h"
@@ skipping 18 matching lines @@
   return 0;
 }
 
 }
 
 class DataFetcherSharedMemoryBase::PollingThread : public base::Thread {
  public:
   PollingThread(const char* name, DataFetcherSharedMemoryBase* fetcher);
   virtual ~PollingThread();
 
-  void AddConsumer(ConsumerType consumer_type);
+  void AddConsumer(ConsumerType consumer_type, void* buffer);
   void RemoveConsumer(ConsumerType consumer_type);
 
   unsigned GetConsumersBitmask() const { return consumers_bitmask_; }
 
  private:
 
   void DoPoll();
 
   unsigned consumers_bitmask_;
   DataFetcherSharedMemoryBase* fetcher_;
   scoped_ptr<base::RepeatingTimer<PollingThread> > timer_;
 
   DISALLOW_COPY_AND_ASSIGN(PollingThread);
 };
 
 // --- PollingThread methods
 
 DataFetcherSharedMemoryBase::PollingThread::PollingThread(
     const char* name, DataFetcherSharedMemoryBase* fetcher)
     : base::Thread(name), consumers_bitmask_(0), fetcher_(fetcher) {
 }
 
 DataFetcherSharedMemoryBase::PollingThread::~PollingThread() {
 }
 
 void DataFetcherSharedMemoryBase::PollingThread::AddConsumer(
-    ConsumerType consumer_type) {
+    ConsumerType consumer_type, void* buffer) {
   DCHECK(fetcher_);
-  if (!fetcher_->Start(consumer_type))
+  if (!fetcher_->Start(consumer_type, buffer))
     return;
 
   consumers_bitmask_ |= consumer_type;
 
   if (!timer_) {
     timer_.reset(new base::RepeatingTimer<PollingThread>());
     timer_->Start(FROM_HERE,
                   base::TimeDelta::FromMilliseconds(kPeriodInMilliseconds),
                   this, &PollingThread::DoPoll);
   }
@@ skipping 33 matching lines @@
 
   STLDeleteContainerPairSecondPointers(shared_memory_map_.begin(),
       shared_memory_map_.end());
 }
 
 bool DataFetcherSharedMemoryBase::StartFetchingDeviceData(
     ConsumerType consumer_type) {
   if (started_consumers_ & consumer_type)
     return true;
 
-  if (!GetSharedMemoryBuffer(consumer_type))
+  void* buffer = GetSharedMemoryBuffer(consumer_type);
+  if (!buffer)
     return false;
 
   if (IsPolling()) {
     if (!InitAndStartPollingThreadIfNecessary())
       return false;
     polling_thread_->message_loop()->PostTask(
         FROM_HERE,
         base::Bind(&PollingThread::AddConsumer,
                    base::Unretained(polling_thread_.get()),
-                   consumer_type));
+                   consumer_type, buffer));
   } else {
-    if (!Start(consumer_type))
+    if (!Start(consumer_type, buffer))
       return false;
   }
 
   started_consumers_ |= consumer_type;
 
   return true;
 }
 
 bool DataFetcherSharedMemoryBase::StopFetchingDeviceData(
     ConsumerType consumer_type) {
@@ skipping 78 matching lines @@
   if (base::SharedMemory* shared_memory = GetSharedMemory(consumer_type))
     return shared_memory->memory();
   return NULL;
 }
 
 base::MessageLoop* DataFetcherSharedMemoryBase::GetPollingMessageLoop() const {
   return polling_thread_ ? polling_thread_->message_loop() : NULL;
 }
 
 }  // namespace content