OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #ifndef CONTENT_RENDERER_SHARED_MEMORY_SEQLOCK_READER_H_ | 5 #ifndef CONTENT_RENDERER_SHARED_MEMORY_SEQLOCK_READER_H_ |
6 #define CONTENT_RENDERER_SHARED_MEMORY_SEQLOCK_READER_H_ | 6 #define CONTENT_RENDERER_SHARED_MEMORY_SEQLOCK_READER_H_ |
7 | 7 |
8 #include <stddef.h> | 8 #include <stddef.h> |
9 | 9 |
10 #include <memory> | 10 #include <memory> |
11 | 11 |
12 #include "base/logging.h" | 12 #include "base/logging.h" |
13 #include "base/macros.h" | 13 #include "base/macros.h" |
14 #include "base/memory/shared_memory.h" | 14 #include "base/memory/shared_memory.h" |
15 #include "content/common/shared_memory_seqlock_buffer.h" | 15 #include "device/generic_sensor/shared_memory_seqlock_buffer.h" |
16 | 16 |
17 namespace content { | 17 namespace content { |
18 namespace internal { | 18 namespace internal { |
19 | 19 |
20 class SharedMemorySeqLockReaderBase { | 20 class SharedMemorySeqLockReaderBase { |
21 protected: | 21 protected: |
22 SharedMemorySeqLockReaderBase(); | 22 SharedMemorySeqLockReaderBase(); |
23 virtual ~SharedMemorySeqLockReaderBase(); | 23 virtual ~SharedMemorySeqLockReaderBase(); |
24 | 24 |
25 void* InitializeSharedMemory( | 25 void* InitializeSharedMemory( |
26 base::SharedMemoryHandle shared_memory_handle, | 26 base::SharedMemoryHandle shared_memory_handle, |
27 size_t buffer_size); | 27 size_t buffer_size); |
28 | 28 |
29 bool FetchFromBuffer(content::OneWriterSeqLock* seqlock, void* final, | 29 bool FetchFromBuffer(device::OneWriterSeqLock* seqlock, |
30 void* temp, void* from, size_t size); | 30 void* final, |
| 31 void* temp, |
| 32 void* from, |
| 33 size_t size); |
31 | 34 |
32 static const int kMaximumContentionCount = 10; | 35 static const int kMaximumContentionCount = 10; |
33 base::SharedMemoryHandle renderer_shared_memory_handle_; | 36 base::SharedMemoryHandle renderer_shared_memory_handle_; |
34 std::unique_ptr<base::SharedMemory> renderer_shared_memory_; | 37 std::unique_ptr<base::SharedMemory> renderer_shared_memory_; |
35 }; | 38 }; |
36 | 39 |
37 } // namespace internal | 40 } // namespace internal |
38 | 41 |
39 // Template argument Data should be a pod-like structure only containing | 42 // Template argument Data should be a pod-like structure only containing |
40 // data fields, such that it is copyable by memcpy method. | 43 // data fields, such that it is copyable by memcpy method. |
41 template<typename Data> | 44 template<typename Data> |
42 class SharedMemorySeqLockReader | 45 class SharedMemorySeqLockReader |
43 : private internal::SharedMemorySeqLockReaderBase { | 46 : private internal::SharedMemorySeqLockReaderBase { |
44 public: | 47 public: |
45 SharedMemorySeqLockReader() : buffer_(0) { } | 48 SharedMemorySeqLockReader() : buffer_(0) { } |
46 virtual ~SharedMemorySeqLockReader() { } | 49 virtual ~SharedMemorySeqLockReader() { } |
47 | 50 |
48 bool GetLatestData(Data* data) { | 51 bool GetLatestData(Data* data) { |
49 DCHECK(buffer_); | 52 DCHECK(buffer_); |
50 DCHECK(sizeof(*data) == sizeof(*temp_buffer_)); | 53 DCHECK(sizeof(*data) == sizeof(*temp_buffer_)); |
51 return FetchFromBuffer(&buffer_->seqlock, data, temp_buffer_.get(), | 54 return FetchFromBuffer(&buffer_->seqlock, data, temp_buffer_.get(), |
52 &buffer_->data, sizeof(*temp_buffer_)); | 55 &buffer_->data, sizeof(*temp_buffer_)); |
53 } | 56 } |
54 | 57 |
55 bool Initialize(base::SharedMemoryHandle shared_memory_handle) { | 58 bool Initialize(base::SharedMemoryHandle shared_memory_handle) { |
56 if (void* memory = InitializeSharedMemory( | 59 if (void* memory = InitializeSharedMemory( |
57 shared_memory_handle, sizeof(SharedMemorySeqLockBuffer<Data>))) { | 60 shared_memory_handle, |
58 buffer_ = static_cast<SharedMemorySeqLockBuffer<Data>*>(memory); | 61 sizeof(device::SharedMemorySeqLockBuffer<Data>))) { |
| 62 buffer_ = static_cast<device::SharedMemorySeqLockBuffer<Data>*>(memory); |
59 temp_buffer_.reset(new Data); | 63 temp_buffer_.reset(new Data); |
60 return true; | 64 return true; |
61 } | 65 } |
62 return false; | 66 return false; |
63 } | 67 } |
64 | 68 |
65 private: | 69 private: |
66 SharedMemorySeqLockBuffer<Data>* buffer_; | 70 device::SharedMemorySeqLockBuffer<Data>* buffer_; |
67 std::unique_ptr<Data> temp_buffer_; | 71 std::unique_ptr<Data> temp_buffer_; |
68 | 72 |
69 DISALLOW_COPY_AND_ASSIGN(SharedMemorySeqLockReader); | 73 DISALLOW_COPY_AND_ASSIGN(SharedMemorySeqLockReader); |
70 }; | 74 }; |
71 | 75 |
72 } // namespace content | 76 } // namespace content |
73 | 77 |
74 #endif // CONTENT_RENDERER_SHARED_MEMORY_SEQLOCK_READER_H_ | 78 #endif // CONTENT_RENDERER_SHARED_MEMORY_SEQLOCK_READER_H_ |
OLD | NEW |