commit 70fadea36f9d742e2e52e223abb6d75bcc5307f5
author Tom Cherry <tomcherry@google.com> Wed May 27 14:43:19 2020 -0700
committer Tom Cherry <tomcherry@google.com> Wed May 27 15:13:52 2020 -0700
tree f273634d4a0253cf4046586a445600bb9355d81f
parent 3e61a1368af0cbcd760c20598870472c5117297f

logd: remove LogBufferElement dependency of LogReaderThread

In the future, not all log buffers will be implemented in terms of
LogBufferElement.

Test: build
Change-Id: I5cf0d01414857b1bfa08c92a4f8035b43ef2aad7

logd/LogReaderThread.cpp

diff --git a/logd/LogReaderThread.cpp b/logd/LogReaderThread.cpp
index 8de9622..3a83f3f 100644
--- a/logd/LogReaderThread.cpp
+++ b/logd/LogReaderThread.cpp
@@ -75,13 +75,21 @@
 
         if (tail_) {
             log_buffer_->FlushTo(writer_.get(), start, nullptr,
-                                 std::bind(&LogReaderThread::FilterFirstPass, this, _1));
+                                 [this](log_id_t log_id, pid_t pid, uint64_t sequence,
+                                        log_time realtime, uint16_t dropped_count) {
+                                     return FilterFirstPass(log_id, pid, sequence, realtime,
+                                                            dropped_count);
+                                 });
             leading_dropped_ =
                     true;  // TODO: Likely a bug, if leading_dropped_ was not true before calling
                            // flushTo(), then it should not be reset to true after.
         }
         start = log_buffer_->FlushTo(writer_.get(), start, last_tid_,
-                                     std::bind(&LogReaderThread::FilterSecondPass, this, _1));
+                                     [this](log_id_t log_id, pid_t pid, uint64_t sequence,
+                                            log_time realtime, uint16_t dropped_count) {
+                                         return FilterSecondPass(log_id, pid, sequence, realtime,
+                                                                 dropped_count);
+                                     });
 
         // We only ignore entries before the original start time for the first flushTo(), if we
         // get entries after this first flush before the original start time, then the client
@@ -123,22 +131,23 @@
 }
 
 // A first pass to count the number of elements
-FilterResult LogReaderThread::FilterFirstPass(const LogBufferElement* element) {
+FilterResult LogReaderThread::FilterFirstPass(log_id_t log_id, pid_t pid, uint64_t sequence,
+                                              log_time realtime, uint16_t dropped_count) {
     auto lock = std::lock_guard{reader_list_->reader_threads_lock()};
 
     if (leading_dropped_) {
-        if (element->getDropped()) {
+        if (dropped_count) {
             return FilterResult::kSkip;
         }
         leading_dropped_ = false;
     }
 
     if (count_ == 0) {
-        start_ = element->getSequence();
+        start_ = sequence;
     }
 
-    if ((!pid_ || pid_ == element->getPid()) && IsWatching(element->getLogId()) &&
-        (start_time_ == log_time::EPOCH || start_time_ <= element->getRealTime())) {
+    if ((!pid_ || pid_ == pid) && IsWatching(log_id) &&
+        (start_time_ == log_time::EPOCH || start_time_ <= realtime)) {
         ++count_;
     }
 
@@ -146,18 +155,19 @@
 }
 
 // A second pass to send the selected elements
-FilterResult LogReaderThread::FilterSecondPass(const LogBufferElement* element) {
+FilterResult LogReaderThread::FilterSecondPass(log_id_t log_id, pid_t pid, uint64_t sequence,
+                                               log_time realtime, uint16_t dropped_count) {
     auto lock = std::lock_guard{reader_list_->reader_threads_lock()};
 
-    start_ = element->getSequence();
+    start_ = sequence;
 
-    if (skip_ahead_[element->getLogId()]) {
-        skip_ahead_[element->getLogId()]--;
+    if (skip_ahead_[log_id]) {
+        skip_ahead_[log_id]--;
         return FilterResult::kSkip;
     }
 
     if (leading_dropped_) {
-        if (element->getDropped()) {
+        if (dropped_count) {
             return FilterResult::kSkip;
         }
         leading_dropped_ = false;
@@ -168,15 +178,15 @@
         return FilterResult::kStop;
     }
 
-    if (!IsWatching(element->getLogId())) {
+    if (!IsWatching(log_id)) {
         return FilterResult::kSkip;
     }
 
-    if (pid_ && pid_ != element->getPid()) {
+    if (pid_ && pid_ != pid) {
         return FilterResult::kSkip;
     }
 
-    if (start_time_ != log_time::EPOCH && element->getRealTime() <= start_time_) {
+    if (start_time_ != log_time::EPOCH && realtime <= start_time_) {
         return FilterResult::kSkip;
     }
 
@@ -199,7 +209,7 @@
     }
 
 ok:
-    if (!skip_ahead_[element->getLogId()]) {
+    if (!skip_ahead_[log_id]) {
         return FilterResult::kWrite;
     }
     return FilterResult::kSkip;