Fix findings of wvla-cxx-extension

This CL fixes occurances of the wvla-cxx-extension warning in
platform/gestures. This is a newly introduced warning in Clang and
existing occurances in ChromeOS break compatibility with future releases
of LLVM.

BUG=b:316021385
TEST=emerge-atlas chromeos-base/gestures

Change-Id: If0eb2999d8a5abc3a367dc1c863d53258804d721
Reviewed-on: https://chromium-review.googlesource.com/c/chromiumos/platform/gestures/+/5160432
Reviewed-by: Harry Cutts <hcutts@chromium.org>
Commit-Queue: Ryan Beltran <ryanbeltran@chromium.org>
Code-Coverage: Sean O'Brien <seobrien@chromium.org>
Tested-by: Ryan Beltran <ryanbeltran@chromium.org>

4 files changed, 45 insertions, 35 deletions

diff --git a/src/iir_filter_interpreter.cc b/src/iir_filter_interpreter.cc
index 5ea513d..84a1faf 100644
--- a/src/iir_filter_interpreter.cc
+++ b/src/iir_filter_interpreter.cc
@@ -5,6 +5,7 @@
 #include "include/iir_filter_interpreter.h"
 
 #include <utility>
+#include <vector>
 
 namespace gestures {
 
@@ -57,14 +58,15 @@ void IirFilterInterpreter::SyncInterpretImpl(HardwareState& hwstate,
   LogHardwareStatePre(name, hwstate);
 
   // Delete old entries from map
-  short dead_ids[histories_.size() + 1];
-  size_t dead_ids_len = 0;
+  std::vector<short> dead_ids;
+  dead_ids.reserve(histories_.size());
+
   for (std::map<short, IoHistory>::iterator it = histories_.begin(),
            e = histories_.end(); it != e; ++it)
     if (!hwstate.GetFingerState((*it).first))
-      dead_ids[dead_ids_len++] = (*it).first;
-  for (size_t i = 0; i < dead_ids_len; ++i)
-    histories_.erase(dead_ids[i]);
+      dead_ids.push_back((*it).first);
+  for (auto dead_id : dead_ids)
+    histories_.erase(dead_id);
 
   // Modify current hwstate
   for (size_t i = 0; i < hwstate.finger_cnt; i++) {
diff --git a/src/immediate_interpreter.cc b/src/immediate_interpreter.cc
index c1aa568..3d362c3 100644
--- a/src/immediate_interpreter.cc
+++ b/src/immediate_interpreter.cc
@@ -11,6 +11,7 @@
 #include <functional>
 #include <limits>
 #include <tuple>
+#include <vector>
 
 #include "include/gestures.h"
 #include "include/logging.h"
@@ -1733,7 +1734,7 @@ FingerMap ImmediateInterpreter::GetGesturingFingers(
     return {};
   }
 
-  const FingerState* fs[hwstate.finger_cnt];
+  std::vector<FingerState*> fs(hwstate.finger_cnt);
   for (size_t i = 0; i < hwstate.finger_cnt; ++i)
     fs[i] = &hwstate.fingers[i];
 
@@ -1743,11 +1744,12 @@ FingerMap ImmediateInterpreter::GetGesturingFingers(
   FingerMap ret;
   size_t sorted_cnt;
   if (hwstate.finger_cnt > kMaxGesturingFingers) {
-    std::partial_sort(fs, fs + kMaxGesturingFingers, fs + hwstate.finger_cnt,
+    std::partial_sort(fs.begin(), fs.begin() + kMaxGesturingFingers,
+                      fs.end(),
                       compare);
     sorted_cnt = kMaxGesturingFingers;
   } else {
-    std::sort(fs, fs + hwstate.finger_cnt, compare);
+    std::sort(fs.begin(), fs.end(), compare);
     sorted_cnt = hwstate.finger_cnt;
   }
   for (size_t i = 0; i < sorted_cnt; i++)
@@ -1975,8 +1977,10 @@ void ImmediateInterpreter::SortFingersByProximity(
   // that until we have enough points
   size_t dist_sq_capacity =
       (finger_ids.size() * (finger_ids.size() - 1)) / 2;
-  DistSqElt dist_sq[dist_sq_capacity];
-  size_t dist_sq_len = 0;
+
+  std::vector<DistSqElt> dist_sq;
+  dist_sq.reserve(dist_sq_capacity);
+
   for (size_t i = 0; i < hwstate.finger_cnt; i++) {
     const FingerState& fs1 = hwstate.fingers[i];
     if (!SetContainsValue(finger_ids, fs1.tracking_id))
@@ -1989,24 +1993,20 @@ void ImmediateInterpreter::SortFingersByProximity(
         DistSq(fs1, fs2),
         { fs1.tracking_id, fs2.tracking_id }
       };
-      if (dist_sq_len >= dist_sq_capacity) {
-        Err("%s: Array overrun", __func__);
-        break;
-      }
-      dist_sq[dist_sq_len++] = elt;
+      dist_sq.push_back(elt);
     }
   }
 
   DistSqCompare distSqCompare;
-  std::sort(dist_sq, dist_sq + dist_sq_len, distSqCompare);
+  std::sort(dist_sq.begin(), dist_sq.end(), distSqCompare);
 
   if (out_sorted_ids == nullptr) {
     Err("out_sorted_ids became null");
     return;
   }
-  for (size_t i = 0; i < dist_sq_len; i++) {
-    short id1 = dist_sq[i].tracking_id[0];
-    short id2 = dist_sq[i].tracking_id[1];
+  for (auto const & d: dist_sq) {
+    short id1 = d.tracking_id[0];
+    short id2 = d.tracking_id[1];
     bool contains1 = out_sorted_ids->find(id1) != out_sorted_ids->end();
     bool contains2 = out_sorted_ids->find(id2) != out_sorted_ids->end();
     if (contains1 == contains2 && !out_sorted_ids->empty()) {
@@ -2463,8 +2463,10 @@ GestureType ImmediateInterpreter::GetMultiFingerGestureType(
     return kGestureTypeNull;
   }
 
-  const FingerState* x_fingers[num_fingers];
-  const FingerState* y_fingers[num_fingers];
+  assert(num_fingers <= (int) kMaxGesturingFingers);
+
+  const FingerState* x_fingers[kMaxGesturingFingers];
+  const FingerState* y_fingers[kMaxGesturingFingers];
   for (int i = 0; i < num_fingers; i++) {
     x_fingers[i] = fingers[i];
     y_fingers[i] = fingers[i];
@@ -2478,13 +2480,13 @@ GestureType ImmediateInterpreter::GetMultiFingerGestureType(
   bool horizontal =
       (x_fingers[num_fingers - 1]->position_x - x_fingers[0]->position_x) >=
       (y_fingers[num_fingers -1]->position_y - y_fingers[0]->position_y);
-  const FingerState* sorted_fingers[num_fingers];
+  const FingerState* sorted_fingers[4];
   for (int i = 0; i < num_fingers; i++) {
     sorted_fingers[i] = horizontal ? x_fingers[i] : y_fingers[i];
   }
 
-  float dx[num_fingers];
-  float dy[num_fingers];
+  float dx[kMaxGesturingFingers];
+  float dy[kMaxGesturingFingers];
   float dy_sum = 0;
   float dx_sum = 0;
   for (int i = 0; i < num_fingers; i++) {
diff --git a/src/lookahead_filter_interpreter.cc b/src/lookahead_filter_interpreter.cc
index 7a5c8fd..767f350 100644
--- a/src/lookahead_filter_interpreter.cc
+++ b/src/lookahead_filter_interpreter.cc
@@ -5,6 +5,7 @@
 #include "include/lookahead_filter_interpreter.h"
 
 #include <algorithm>
+#include <memory>
 #include <math.h>
 
 #include "include/tracer.h"
@@ -472,7 +473,8 @@ void LookaheadFilterInterpreter::HandleTimerImpl(stime_t now,
       // SyncInterpret
       last_interpreted_time_ = node->state_.timestamp;
       const size_t finger_cnt = node->state_.finger_cnt;
-      FingerState fs_copy[std::max(finger_cnt,(size_t)1)];
+      auto fs_copy =
+        std::make_unique<FingerState[]>(std::max(finger_cnt, (size_t)1));
       std::copy(&node->state_.fingers[0],
                 &node->state_.fingers[finger_cnt],
                 &fs_copy[0]);
@@ -481,7 +483,7 @@ void LookaheadFilterInterpreter::HandleTimerImpl(stime_t now,
         node->state_.buttons_down,
         node->state_.finger_cnt,
         node->state_.touch_cnt,
-        fs_copy,
+        fs_copy.get(),
         node->state_.rel_x,
         node->state_.rel_y,
         node->state_.rel_wheel,
diff --git a/src/prop_registry.cc b/src/prop_registry.cc
index 283db9d..244ebf2 100644
--- a/src/prop_registry.cc
+++ b/src/prop_registry.cc
@@ -106,15 +106,17 @@ void BoolProperty::HandleGesturesPropWritten() {
 }
 
 void BoolArrayProperty::CreatePropImpl() {
-  GesturesPropBool orig_vals[count_];
-  memcpy(orig_vals, vals_, sizeof(orig_vals));
+  auto orig_vals = std::make_unique<GesturesPropBool[]>(count_);
+
+  memcpy(orig_vals.get(), vals_, count_ * sizeof(GesturesPropBool));
   gprop_ = parent_->PropProvider()->create_bool_fn(
       parent_->PropProviderData(),
       name(),
       vals_,
       count_,
       vals_);
-  if (delegate_ && memcmp(orig_vals, vals_, sizeof(orig_vals)))
+  if (delegate_ && memcmp(orig_vals.get(), vals_,
+                          count_ * sizeof(GesturesPropBool)))
     delegate_->BoolArrayWasWritten(this);
 }
 
@@ -182,15 +184,16 @@ void DoubleProperty::HandleGesturesPropWritten() {
 }
 
 void DoubleArrayProperty::CreatePropImpl() {
-  float orig_vals[count_];
-  memcpy(orig_vals, vals_, sizeof(orig_vals));
+  auto orig_vals = std::make_unique<float[]>(count_);
+
+  memcpy(orig_vals.get(), vals_, count_ * sizeof(float));
   gprop_ = parent_->PropProvider()->create_real_fn(
       parent_->PropProviderData(),
       name(),
       vals_,
       count_,
       vals_);
-  if (delegate_ && memcmp(orig_vals, vals_, sizeof(orig_vals)))
+  if (delegate_ && memcmp(orig_vals.get(), vals_, count_ * sizeof(float)))
     delegate_->DoubleArrayWasWritten(this);
 }
 
@@ -263,15 +266,16 @@ void IntProperty::HandleGesturesPropWritten() {
 }
 
 void IntArrayProperty::CreatePropImpl() {
-  int orig_vals[count_];
-  memcpy(orig_vals, vals_, sizeof(orig_vals));
+  auto orig_vals = std::make_unique<int[]>(count_);
+
+  memcpy(orig_vals.get(), vals_, count_ * sizeof(int));
   gprop_ = parent_->PropProvider()->create_int_fn(
       parent_->PropProviderData(),
       name(),
       vals_,
       count_,
       vals_);
-  if (delegate_ && memcmp(orig_vals, vals_, sizeof(orig_vals)))
+  if (delegate_ && memcmp(orig_vals.get(), vals_, count_ * sizeof(int)))
     delegate_->IntArrayWasWritten(this);
 }