diff --git a/modules/camera/3_4/metadata/ignored_control.h b/modules/camera/3_4/metadata/ignored_control.h
index ef36784..aea8988 100644
--- a/modules/camera/3_4/metadata/ignored_control.h
+++ b/modules/camera/3_4/metadata/ignored_control.h
@@ -31,8 +31,10 @@
 template <typename T>
 class IgnoredControl : public OptionedControl<T> {
  public:
-  IgnoredControl(int32_t control_tag, int32_t options_tag,
-                 std::vector<T> options, T default_option)
+  IgnoredControl(int32_t control_tag,
+                 int32_t options_tag,
+                 std::vector<T> options,
+                 T default_option)
       : OptionedControl<T>(control_tag, options_tag, options),
         // Note: default option is not enforced as being in |options|,
         // but it may be confusing if it isn't.
diff --git a/modules/camera/3_4/metadata/ignored_control_test.cpp b/modules/camera/3_4/metadata/ignored_control_test.cpp
index bab3754..04408d2 100644
--- a/modules/camera/3_4/metadata/ignored_control_test.cpp
+++ b/modules/camera/3_4/metadata/ignored_control_test.cpp
@@ -41,8 +41,8 @@
         default_option_(options_[2]) {}
 
   virtual void SetUp() {
-    control_.reset(new IgnoredControl<uint8_t>(control_tag_, options_tag_,
-                                               options_, default_option_));
+    control_.reset(new IgnoredControl<uint8_t>(
+        control_tag_, options_tag_, options_, default_option_));
   }
 
   std::unique_ptr<IgnoredControl<uint8_t>> control_;
diff --git a/modules/camera/3_4/metadata/metadata.cpp b/modules/camera/3_4/metadata/metadata.cpp
index 0d03d5f..61336fe 100644
--- a/modules/camera/3_4/metadata/metadata.cpp
+++ b/modules/camera/3_4/metadata/metadata.cpp
@@ -22,9 +22,13 @@
 
 namespace v4l2_camera_hal {
 
-Metadata::Metadata() { HAL_LOG_ENTER(); }
+Metadata::Metadata() {
+  HAL_LOG_ENTER();
+}
 
-Metadata::~Metadata() { HAL_LOG_ENTER(); }
+Metadata::~Metadata() {
+  HAL_LOG_ENTER();
+}
 
 void Metadata::AddComponent(
     std::unique_ptr<PartialMetadataInterface> component) {
@@ -71,21 +75,24 @@
   // Populate the meta fields.
   static_tags.push_back(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS);
   res = metadata->update(ANDROID_REQUEST_AVAILABLE_REQUEST_KEYS,
-                         control_tags.data(), control_tags.size());
+                         control_tags.data(),
+                         control_tags.size());
   if (res != android::OK) {
     HAL_LOGE("Failed to add request keys meta key.");
     return -ENODEV;
   }
   static_tags.push_back(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS);
   res = metadata->update(ANDROID_REQUEST_AVAILABLE_RESULT_KEYS,
-                         dynamic_tags.data(), dynamic_tags.size());
+                         dynamic_tags.data(),
+                         dynamic_tags.size());
   if (res != android::OK) {
     HAL_LOGE("Failed to add result keys meta key.");
     return -ENODEV;
   }
   static_tags.push_back(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS);
   res = metadata->update(ANDROID_REQUEST_AVAILABLE_CHARACTERISTICS_KEYS,
-                         static_tags.data(), static_tags.size());
+                         static_tags.data(),
+                         static_tags.size());
   if (res != android::OK) {
     HAL_LOGE("Failed to add characteristics keys meta key.");
     return -ENODEV;
@@ -98,7 +105,8 @@
   HAL_LOG_ENTER();
 
   // Empty means "use previous settings", which are inherently valid.
-  if (metadata.isEmpty()) return true;
+  if (metadata.isEmpty())
+    return true;
 
   for (auto& component : components_) {
     // Check that all components support the values requested of them.
@@ -116,7 +124,8 @@
   HAL_LOG_ENTER();
 
   // Empty means "use previous settings".
-  if (metadata.isEmpty()) return 0;
+  if (metadata.isEmpty())
+    return 0;
 
   for (auto& component : components_) {
     int res = component->SetRequestValues(metadata);
diff --git a/modules/camera/3_4/metadata/metadata_common.h b/modules/camera/3_4/metadata/metadata_common.h
index 55f8a6f..efea152 100644
--- a/modules/camera/3_4/metadata/metadata_common.h
+++ b/modules/camera/3_4/metadata/metadata_common.h
@@ -53,8 +53,10 @@
 
 // Generic (pointer & size).
 template <typename T>
-static int UpdateMetadata(android::CameraMetadata* metadata, int32_t tag,
-                          const T* data, size_t count) {
+static int UpdateMetadata(android::CameraMetadata* metadata,
+                          int32_t tag,
+                          const T* data,
+                          size_t count) {
   int res = metadata->update(tag, data, count);
   if (res) {
     HAL_LOGE("Failed to update metadata tag %d", tag);
@@ -65,35 +67,40 @@
 
 // Generic (single item reference).
 template <typename T>
-static int UpdateMetadata(android::CameraMetadata* metadata, int32_t tag,
+static int UpdateMetadata(android::CameraMetadata* metadata,
+                          int32_t tag,
                           const T& val) {
   return UpdateMetadata(metadata, tag, &val, 1);
 }
 
 // Specialization for vectors.
 template <typename T>
-static int UpdateMetadata(android::CameraMetadata* metadata, int32_t tag,
+static int UpdateMetadata(android::CameraMetadata* metadata,
+                          int32_t tag,
                           const std::vector<T>& val) {
   return UpdateMetadata(metadata, tag, val.data(), val.size());
 }
 
 // Specialization for arrays.
 template <typename T, size_t N>
-static int UpdateMetadata(android::CameraMetadata* metadata, int32_t tag,
+static int UpdateMetadata(android::CameraMetadata* metadata,
+                          int32_t tag,
                           const std::array<T, N>& val) {
   return UpdateMetadata(metadata, tag, val.data(), N);
 }
 
 // Specialization for ArrayVectors.
 template <typename T, size_t N>
-static int UpdateMetadata(android::CameraMetadata* metadata, int32_t tag,
+static int UpdateMetadata(android::CameraMetadata* metadata,
+                          int32_t tag,
                           const ArrayVector<T, N>& val) {
   return UpdateMetadata(metadata, tag, val.data(), val.total_num_elements());
 }
 
 // Specialization for vectors of arrays.
 template <typename T, size_t N>
-static int UpdateMetadata(android::CameraMetadata* metadata, int32_t tag,
+static int UpdateMetadata(android::CameraMetadata* metadata,
+                          int32_t tag,
                           const std::vector<std::array<T, N>>& val) {
   // Convert to array vector so we know all the elements are contiguous.
   ArrayVector<T, N> array_vector;
@@ -154,7 +161,8 @@
 
 // Singleton.
 template <typename T>
-static int SingleTagValue(const android::CameraMetadata& metadata, int32_t tag,
+static int SingleTagValue(const android::CameraMetadata& metadata,
+                          int32_t tag,
                           T* val) {
   camera_metadata_ro_entry_t entry = metadata.find(tag);
   if (entry.count == 0) {
@@ -164,7 +172,8 @@
     HAL_LOGE(
         "Error: expected metadata tag %d to contain exactly 1 value "
         "(had %d).",
-        tag, entry.count);
+        tag,
+        entry.count);
     return -EINVAL;
   }
   const T* data = nullptr;
@@ -179,7 +188,8 @@
 
 // Specialization for std::array.
 template <typename T, size_t N>
-static int SingleTagValue(const android::CameraMetadata& metadata, int32_t tag,
+static int SingleTagValue(const android::CameraMetadata& metadata,
+                          int32_t tag,
                           std::array<T, N>* val) {
   camera_metadata_ro_entry_t entry = metadata.find(tag);
   if (entry.count == 0) {
@@ -189,7 +199,9 @@
     HAL_LOGE(
         "Error: expected metadata tag %d to contain a single array of "
         "exactly %d values (had %d).",
-        tag, N, entry.count);
+        tag,
+        N,
+        entry.count);
     return -EINVAL;
   }
   const T* data = nullptr;
diff --git a/modules/camera/3_4/metadata/optioned_control.h b/modules/camera/3_4/metadata/optioned_control.h
index 10052cc..e205a59 100644
--- a/modules/camera/3_4/metadata/optioned_control.h
+++ b/modules/camera/3_4/metadata/optioned_control.h
@@ -33,7 +33,8 @@
 template <typename T>
 class OptionedControl : public Control<T> {
  public:
-  OptionedControl(int32_t control_tag, int32_t options_tag,
+  OptionedControl(int32_t control_tag,
+                  int32_t options_tag,
                   std::vector<T> options);
 
   virtual int PopulateStaticFields(
@@ -57,7 +58,8 @@
 // -----------------------------------------------------------------------------
 
 template <typename T>
-OptionedControl<T>::OptionedControl(int32_t control_tag, int32_t options_tag,
+OptionedControl<T>::OptionedControl(int32_t control_tag,
+                                    int32_t options_tag,
                                     std::vector<T> options)
     : Control<T>(control_tag, {options_tag}), options_(std::move(options)) {
   HAL_LOG_ENTER();
diff --git a/modules/camera/3_4/metadata/optioned_control_test.cpp b/modules/camera/3_4/metadata/optioned_control_test.cpp
index 1cfccbf..bd9b705 100644
--- a/modules/camera/3_4/metadata/optioned_control_test.cpp
+++ b/modules/camera/3_4/metadata/optioned_control_test.cpp
@@ -36,7 +36,8 @@
   template <typename T>
   class MockOptionedControl : public OptionedControl<T> {
    public:
-    MockOptionedControl(int32_t control_tag, int32_t options_tag,
+    MockOptionedControl(int32_t control_tag,
+                        int32_t options_tag,
                         std::vector<T> options)
         : OptionedControl<T>(control_tag, options_tag, options){};
     MOCK_CONST_METHOD1_T(GetValue, int(T* value));
diff --git a/modules/camera/3_4/metadata/test_common.h b/modules/camera/3_4/metadata/test_common.h
index 6cbd611..489990f 100644
--- a/modules/camera/3_4/metadata/test_common.h
+++ b/modules/camera/3_4/metadata/test_common.h
@@ -32,7 +32,9 @@
 // Generic.
 template <typename T>
 static void ExpectMetadataEq(const android::CameraMetadata& metadata,
-                             int32_t tag, const T* expected, size_t size) {
+                             int32_t tag,
+                             const T* expected,
+                             size_t size) {
   camera_metadata_ro_entry_t entry = metadata.find(tag);
   ASSERT_EQ(entry.count, size);
   const T* data = nullptr;
@@ -46,30 +48,34 @@
 // Single item.
 template <typename T>
 static void ExpectMetadataEq(const android::CameraMetadata& metadata,
-                             int32_t tag, T expected) {
+                             int32_t tag,
+                             T expected) {
   ExpectMetadataEq(metadata, tag, &expected, 1);
 }
 
 // Vector of items.
 template <typename T>
 static void ExpectMetadataEq(const android::CameraMetadata& metadata,
-                             int32_t tag, const std::vector<T>& expected) {
+                             int32_t tag,
+                             const std::vector<T>& expected) {
   ExpectMetadataEq(metadata, tag, expected.data(), expected.size());
 }
 
 // Array of items.
 template <typename T, size_t N>
 static void ExpectMetadataEq(const android::CameraMetadata& metadata,
-                             int32_t tag, const std::array<T, N>& expected) {
+                             int32_t tag,
+                             const std::array<T, N>& expected) {
   ExpectMetadataEq(metadata, tag, expected.data(), N);
 }
 
 // ArrayVector.
 template <typename T, size_t N>
 static void ExpectMetadataEq(const android::CameraMetadata& metadata,
-                             int32_t tag, const ArrayVector<T, N>& expected) {
-  ExpectMetadataEq(metadata, tag, expected.data(),
-                   expected.total_num_elements());
+                             int32_t tag,
+                             const ArrayVector<T, N>& expected) {
+  ExpectMetadataEq(
+      metadata, tag, expected.data(), expected.total_num_elements());
 }
 
 // Vector of arrays.
diff --git a/modules/camera/3_4/metadata/v4l2_enum_control.cpp b/modules/camera/3_4/metadata/v4l2_enum_control.cpp
index 58e1b6b..9968b0b 100644
--- a/modules/camera/3_4/metadata/v4l2_enum_control.cpp
+++ b/modules/camera/3_4/metadata/v4l2_enum_control.cpp
@@ -21,8 +21,11 @@
 namespace v4l2_camera_hal {
 
 V4L2EnumControl* V4L2EnumControl::NewV4L2EnumControl(
-    std::shared_ptr<V4L2Wrapper> device, int v4l2_control, int32_t control_tag,
-    int32_t options_tag, const std::map<int32_t, uint8_t>& v4l2_to_metadata) {
+    std::shared_ptr<V4L2Wrapper> device,
+    int v4l2_control,
+    int32_t control_tag,
+    int32_t options_tag,
+    const std::map<int32_t, uint8_t>& v4l2_to_metadata) {
   HAL_LOG_ENTER();
 
   // Query the device.
@@ -37,7 +40,8 @@
     HAL_LOGE(
         "Enum controls can only be constructed from V4L2 menu and boolean "
         "controls (%d is of type %d)",
-        v4l2_control, control_query.type);
+        v4l2_control,
+        control_query.type);
     return nullptr;
   }
 
@@ -46,7 +50,8 @@
   int32_t control_max = static_cast<int32_t>(control_query.maximum);
   // Query maximum is inclusive.
   for (int32_t i = static_cast<int32_t>(control_query.minimum);
-       i <= control_max; i += control_query.step) {
+       i <= control_max;
+       i += control_query.step) {
     auto map_entry = v4l2_to_metadata.find(i);
     if (map_entry == v4l2_to_metadata.end()) {
       HAL_LOGW("Control %d has unknown option %d.", v4l2_control, i);
@@ -60,13 +65,20 @@
   }
 
   // Construct the device.
-  return new V4L2EnumControl(device, v4l2_control, control_tag, options_tag,
-                             std::move(v4l2_to_metadata), std::move(options));
+  return new V4L2EnumControl(device,
+                             v4l2_control,
+                             control_tag,
+                             options_tag,
+                             std::move(v4l2_to_metadata),
+                             std::move(options));
 }
 
 V4L2EnumControl::V4L2EnumControl(
-    std::shared_ptr<V4L2Wrapper> device, int v4l2_control, int32_t control_tag,
-    int32_t options_tag, const std::map<int32_t, uint8_t> v4l2_to_metadata,
+    std::shared_ptr<V4L2Wrapper> device,
+    int v4l2_control,
+    int32_t control_tag,
+    int32_t options_tag,
+    const std::map<int32_t, uint8_t> v4l2_to_metadata,
     std::vector<uint8_t> options)
     : OptionedControl<uint8_t>(control_tag, options_tag, std::move(options)),
       device_(device),
diff --git a/modules/camera/3_4/metadata/v4l2_enum_control.h b/modules/camera/3_4/metadata/v4l2_enum_control.h
index 93fc0e2..f4027b8 100644
--- a/modules/camera/3_4/metadata/v4l2_enum_control.h
+++ b/modules/camera/3_4/metadata/v4l2_enum_control.h
@@ -36,16 +36,20 @@
   // Functionally equivalent to "new V4L2EnumControl"
   // except that it may return nullptr in case of failure.
   static V4L2EnumControl* NewV4L2EnumControl(
-      std::shared_ptr<V4L2Wrapper> device, int v4l2_control,
-      int32_t control_tag, int32_t options_tag,
+      std::shared_ptr<V4L2Wrapper> device,
+      int v4l2_control,
+      int32_t control_tag,
+      int32_t options_tag,
       const std::map<int32_t, uint8_t>& v4l2_to_metadata);
 
  private:
   // Constructor private to allow failing on bad input.
   // Use NewV4L2EnumControl instead.
   // The values in |v4l2_to_metadata| must be a superset of |options|.
-  V4L2EnumControl(std::shared_ptr<V4L2Wrapper> device, int v4l2_control,
-                  int32_t control_tag, int32_t options_tag,
+  V4L2EnumControl(std::shared_ptr<V4L2Wrapper> device,
+                  int v4l2_control,
+                  int32_t control_tag,
+                  int32_t options_tag,
                   const std::map<int32_t, uint8_t> v4l2_to_metadata,
                   std::vector<uint8_t> options);
 
diff --git a/modules/camera/3_4/metadata/v4l2_enum_control_test.cpp b/modules/camera/3_4/metadata/v4l2_enum_control_test.cpp
index 54f78f3..05257c8 100644
--- a/modules/camera/3_4/metadata/v4l2_enum_control_test.cpp
+++ b/modules/camera/3_4/metadata/v4l2_enum_control_test.cpp
@@ -43,8 +43,12 @@
 
   virtual void SetUp() {
     device_.reset(new V4L2WrapperMock());
-    control_.reset(new V4L2EnumControl(device_, v4l2_control_, control_tag_,
-                                       options_tag_, options_map_, options_));
+    control_.reset(new V4L2EnumControl(device_,
+                                       v4l2_control_,
+                                       control_tag_,
+                                       options_tag_,
+                                       options_map_,
+                                       options_));
   }
 
   virtual uint8_t V4L2ToMetadata(int32_t value) {
@@ -83,8 +87,8 @@
       .WillOnce(DoAll(SetArgPointee<1>(query_result), Return(0)));
 
   std::unique_ptr<V4L2EnumControl> test_control(
-      V4L2EnumControl::NewV4L2EnumControl(device_, v4l2_control_, control_tag_,
-                                          options_tag_, options_map_));
+      V4L2EnumControl::NewV4L2EnumControl(
+          device_, v4l2_control_, control_tag_, options_tag_, options_map_));
   // Shouldn't be null.
   ASSERT_NE(test_control.get(), nullptr);
 
@@ -119,8 +123,8 @@
   EXPECT_CALL(*device_, QueryControl(v4l2_control_, _)).WillOnce(Return(err));
 
   std::unique_ptr<V4L2EnumControl> test_control(
-      V4L2EnumControl::NewV4L2EnumControl(device_, v4l2_control_, control_tag_,
-                                          options_tag_, options_map_));
+      V4L2EnumControl::NewV4L2EnumControl(
+          device_, v4l2_control_, control_tag_, options_tag_, options_map_));
   // Should return null to indicate error.
   ASSERT_EQ(test_control.get(), nullptr);
 }
@@ -136,8 +140,8 @@
       .WillOnce(DoAll(SetArgPointee<1>(query_result), Return(0)));
 
   std::unique_ptr<V4L2EnumControl> test_control(
-      V4L2EnumControl::NewV4L2EnumControl(device_, v4l2_control_, control_tag_,
-                                          options_tag_, options_map_));
+      V4L2EnumControl::NewV4L2EnumControl(
+          device_, v4l2_control_, control_tag_, options_tag_, options_map_));
   // Should return null to indicate error.
   ASSERT_FALSE(test_control);
 }
@@ -167,8 +171,8 @@
 TEST_F(V4L2EnumControlTest, SetUnmapped) {
   // If the enum control is validly constructed, this should never happen.
   // Purposefully misconstruct a device for this test (empty map).
-  V4L2EnumControl test_control(device_, v4l2_control_, control_tag_,
-                               options_tag_, {}, options_);
+  V4L2EnumControl test_control(
+      device_, v4l2_control_, control_tag_, options_tag_, {}, options_);
   EXPECT_EQ(test_control.SetValue(options_[0]), -ENODEV);
 }
 
diff --git a/modules/camera/3_4/v4l2_metadata.cpp b/modules/camera/3_4/v4l2_metadata.cpp
index 9ec892f..0ad667b 100644
--- a/modules/camera/3_4/v4l2_metadata.cpp
+++ b/modules/camera/3_4/v4l2_metadata.cpp
@@ -51,7 +51,8 @@
   AddComponent(std::unique_ptr<PartialMetadataInterface>(
       new FixedProperty<std::array<int32_t, 3>>(
           ANDROID_CONTROL_MAX_REGIONS, {{/*AE*/ 0, /*AWB*/ 0, /*AF*/ 0}})));
-  AddEnumControlOrDefault(V4L2_CID_EXPOSURE_AUTO, ANDROID_CONTROL_AE_MODE,
+  AddEnumControlOrDefault(V4L2_CID_EXPOSURE_AUTO,
+                          ANDROID_CONTROL_AE_MODE,
                           ANDROID_CONTROL_AE_AVAILABLE_MODES,
                           {{V4L2_EXPOSURE_AUTO, ANDROID_CONTROL_AE_MODE_ON},
                            {V4L2_EXPOSURE_MANUAL, ANDROID_CONTROL_AE_MODE_OFF}},
@@ -76,8 +77,10 @@
   // V4L2: FLUORESCENT_H, HORIZON, FLASH.
   std::unique_ptr<PartialMetadataInterface> awb(
       V4L2EnumControl::NewV4L2EnumControl(
-          device_, V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE,
-          ANDROID_CONTROL_AWB_MODE, ANDROID_CONTROL_AWB_AVAILABLE_MODES,
+          device_,
+          V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE,
+          ANDROID_CONTROL_AWB_MODE,
+          ANDROID_CONTROL_AWB_AVAILABLE_MODES,
           {{V4L2_WHITE_BALANCE_MANUAL, ANDROID_CONTROL_AWB_MODE_OFF},
            {V4L2_WHITE_BALANCE_AUTO, ANDROID_CONTROL_AWB_MODE_AUTO},
            {V4L2_WHITE_BALANCE_INCANDESCENT,
@@ -93,7 +96,8 @@
   } else {
     // Fall back to simpler AWB or even just an ignored control.
     AddEnumControlOrDefault(
-        V4L2_CID_AUTO_WHITE_BALANCE, ANDROID_CONTROL_AWB_MODE,
+        V4L2_CID_AUTO_WHITE_BALANCE,
+        ANDROID_CONTROL_AWB_MODE,
         ANDROID_CONTROL_AWB_AVAILABLE_MODES,
         {{0, ANDROID_CONTROL_AWB_MODE_OFF}, {1, ANDROID_CONTROL_AWB_MODE_AUTO}},
         ANDROID_CONTROL_AWB_MODE_AUTO);
@@ -106,7 +110,8 @@
   // is reported to avoid ambiguity).
   // V4L2: BACKLIGHT, DAWN_DUSK, FALL_COLORS, TEXT.
   AddEnumControlOrDefault(
-      V4L2_CID_SCENE_MODE, ANDROID_CONTROL_SCENE_MODE,
+      V4L2_CID_SCENE_MODE,
+      ANDROID_CONTROL_SCENE_MODE,
       ANDROID_CONTROL_AVAILABLE_SCENE_MODES,
       {{V4L2_SCENE_MODE_NONE, ANDROID_CONTROL_SCENE_MODE_DISABLED},
        {V4L2_SCENE_MODE_BEACH_SNOW, ANDROID_CONTROL_SCENE_MODE_BEACH},
@@ -123,7 +128,8 @@
   // V4L2: ANTIQUE, ART_FREEZE, EMBOSS, GRASS_GREEN, SKETCH, SKIN_WHITEN,
   // SKY_BLUE, SILHOUETTE, VIVID, SET_CBCR.
   AddEnumControlOrDefault(
-      V4L2_CID_COLORFX, ANDROID_CONTROL_EFFECT_MODE,
+      V4L2_CID_COLORFX,
+      ANDROID_CONTROL_EFFECT_MODE,
       ANDROID_CONTROL_AVAILABLE_EFFECTS,
       {{V4L2_COLORFX_NONE, ANDROID_CONTROL_EFFECT_MODE_OFF},
        {V4L2_COLORFX_BW, ANDROID_CONTROL_EFFECT_MODE_MONO},
@@ -136,17 +142,19 @@
   // Not sure if V4L2 does or doesn't do this, but HAL documentation says
   // all devices must support FAST, and FAST can be equivalent to OFF, so
   // either way it's fine to list.
-  AddComponent(
-      std::unique_ptr<PartialMetadataInterface>(new IgnoredControl<uint8_t>(
-          ANDROID_EDGE_MODE, ANDROID_EDGE_AVAILABLE_EDGE_MODES,
-          {ANDROID_EDGE_MODE_FAST}, ANDROID_EDGE_MODE_FAST)));
+  AddComponent(std::unique_ptr<PartialMetadataInterface>(
+      new IgnoredControl<uint8_t>(ANDROID_EDGE_MODE,
+                                  ANDROID_EDGE_AVAILABLE_EDGE_MODES,
+                                  {ANDROID_EDGE_MODE_FAST},
+                                  ANDROID_EDGE_MODE_FAST)));
 
   // TODO(30510395): subcomponents of hotpixel.
   // No known V4L2 hot pixel correction. But it might be happening,
   // so we report FAST/HIGH_QUALITY.
   AddComponent(
       std::unique_ptr<PartialMetadataInterface>(new IgnoredControl<uint8_t>(
-          ANDROID_HOT_PIXEL_MODE, ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES,
+          ANDROID_HOT_PIXEL_MODE,
+          ANDROID_HOT_PIXEL_AVAILABLE_HOT_PIXEL_MODES,
           {ANDROID_HOT_PIXEL_MODE_FAST, ANDROID_HOT_PIXEL_MODE_HIGH_QUALITY},
           ANDROID_HOT_PIXEL_MODE_FAST)));
   // ON only needs to be supported for RAW capable devices.
@@ -160,20 +168,23 @@
   // TODO(30510395): subcomponents focus/lens.
   // No way to actually get the aperture and focal length
   // in V4L2, but they're required keys, so fake them.
-  AddComponent(
-      std::unique_ptr<PartialMetadataInterface>(new IgnoredControl<float>(
-          ANDROID_LENS_APERTURE, ANDROID_LENS_INFO_AVAILABLE_APERTURES, {2.0},
-          2.0)));  // RPi camera v2 is f/2.0.
-  AddComponent(
-      std::unique_ptr<PartialMetadataInterface>(new IgnoredControl<float>(
-          ANDROID_LENS_FOCAL_LENGTH, ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
-          {3.04}, 3.04)));  // RPi camera v2 is 3.04mm.
+  AddComponent(std::unique_ptr<PartialMetadataInterface>(
+      new IgnoredControl<float>(ANDROID_LENS_APERTURE,
+                                ANDROID_LENS_INFO_AVAILABLE_APERTURES,
+                                {2.0},
+                                2.0)));  // RPi camera v2 is f/2.0.
+  AddComponent(std::unique_ptr<PartialMetadataInterface>(
+      new IgnoredControl<float>(ANDROID_LENS_FOCAL_LENGTH,
+                                ANDROID_LENS_INFO_AVAILABLE_FOCAL_LENGTHS,
+                                {3.04},
+                                3.04)));  // RPi camera v2 is 3.04mm.
   // No known way to get filter densities from V4L2,
   // report 0 to indicate this control is not supported.
-  AddComponent(
-      std::unique_ptr<PartialMetadataInterface>(new IgnoredControl<float>(
-          ANDROID_LENS_FILTER_DENSITY,
-          ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES, {0.0}, 0.0)));
+  AddComponent(std::unique_ptr<PartialMetadataInterface>(
+      new IgnoredControl<float>(ANDROID_LENS_FILTER_DENSITY,
+                                ANDROID_LENS_INFO_AVAILABLE_FILTER_DENSITIES,
+                                {0.0},
+                                0.0)));
   // V4L2 focal units do not correspond to a particular physical unit.
   AddComponent(
       std::unique_ptr<PartialMetadataInterface>(new FixedProperty<uint8_t>(
@@ -184,7 +195,8 @@
   // so report FAST/HIGH_QUALITY.
   AddComponent(
       std::unique_ptr<PartialMetadataInterface>(new IgnoredControl<uint8_t>(
-          ANDROID_SHADING_MODE, ANDROID_SHADING_AVAILABLE_MODES,
+          ANDROID_SHADING_MODE,
+          ANDROID_SHADING_AVAILABLE_MODES,
           {ANDROID_SHADING_MODE_FAST, ANDROID_SHADING_MODE_HIGH_QUALITY},
           ANDROID_SHADING_MODE_FAST)));
   // ON only needs to be supported for RAW capable devices.
@@ -224,8 +236,10 @@
   // since V4L2 doesn't actually allow for thumbnail size control.
   AddComponent(std::unique_ptr<PartialMetadataInterface>(
       new IgnoredControl<std::array<int32_t, 2>>(
-          ANDROID_JPEG_THUMBNAIL_SIZE, ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
-          {{{0, 0}}}, {{0, 0}})));
+          ANDROID_JPEG_THUMBNAIL_SIZE,
+          ANDROID_JPEG_AVAILABLE_THUMBNAIL_SIZES,
+          {{{0, 0}}},
+          {{0, 0}})));
   // TODO(b/29939583): V4L2 can only support 1 stream at a time.
   // For now, just reporting minimum allowable for LIMITED devices.
   AddComponent(std::unique_ptr<PartialMetadataInterface>(
@@ -296,20 +310,25 @@
           {ANDROID_REQUEST_AVAILABLE_CAPABILITIES_BACKWARD_COMPATIBLE})));
 }
 
-V4L2Metadata::~V4L2Metadata() { HAL_LOG_ENTER(); }
+V4L2Metadata::~V4L2Metadata() {
+  HAL_LOG_ENTER();
+}
 
 void V4L2Metadata::AddEnumControlOrDefault(
-    int v4l2_control, int32_t control_tag, int32_t options_tag,
-    const std::map<int32_t, uint8_t>& v4l2_to_metadata, uint8_t default_value) {
+    int v4l2_control,
+    int32_t control_tag,
+    int32_t options_tag,
+    const std::map<int32_t, uint8_t>& v4l2_to_metadata,
+    uint8_t default_value) {
   HAL_LOG_ENTER();
 
   std::unique_ptr<PartialMetadataInterface> control(
-      V4L2EnumControl::NewV4L2EnumControl(device_, v4l2_control, control_tag,
-                                          options_tag, v4l2_to_metadata));
+      V4L2EnumControl::NewV4L2EnumControl(
+          device_, v4l2_control, control_tag, options_tag, v4l2_to_metadata));
 
   if (!control) {
-    control.reset(new IgnoredControl<uint8_t>(control_tag, options_tag,
-                                              {default_value}, default_value));
+    control.reset(new IgnoredControl<uint8_t>(
+        control_tag, options_tag, {default_value}, default_value));
   }
 
   AddComponent(std::move(control));
diff --git a/modules/camera/3_4/v4l2_metadata.h b/modules/camera/3_4/v4l2_metadata.h
index f99ceac..a046d3f 100644
--- a/modules/camera/3_4/v4l2_metadata.h
+++ b/modules/camera/3_4/v4l2_metadata.h
@@ -37,7 +37,9 @@
   // Attempt to construct and add an enum control. If construction fails,
   // use an IgnoredControl with only the default value instead.
   void AddEnumControlOrDefault(
-      int v4l2_control, int32_t control_tag, int32_t options_tag,
+      int v4l2_control,
+      int32_t control_tag,
+      int32_t options_tag,
       const std::map<int32_t, uint8_t>& v4l2_to_metadata,
       uint8_t default_value);
 
diff --git a/modules/camera/3_4/v4l2_wrapper.cpp b/modules/camera/3_4/v4l2_wrapper.cpp
index 7d8e38c..ca38168 100644
--- a/modules/camera/3_4/v4l2_wrapper.cpp
+++ b/modules/camera/3_4/v4l2_wrapper.cpp
@@ -60,7 +60,9 @@
   HAL_LOG_ENTER();
 }
 
-V4L2Wrapper::~V4L2Wrapper() { HAL_LOG_ENTER(); }
+V4L2Wrapper::~V4L2Wrapper() {
+  HAL_LOG_ENTER();
+}
 
 int V4L2Wrapper::Connect() {
   HAL_LOG_ENTER();
@@ -101,14 +103,16 @@
   if (connection_count_ == 0) {
     // Not connected.
     HAL_LOGE("Camera device %s is not connected, cannot disconnect.",
-             device_path_.c_str(), connection_count_);
+             device_path_.c_str(),
+             connection_count_);
     return;
   }
 
   --connection_count_;
   if (connection_count_ > 0) {
     HAL_LOGV("Disconnected from camera device %s. %d connections remain.",
-             device_path_.c_str(), connection_count_);
+             device_path_.c_str(),
+             connection_count_);
     return;
   }
 
@@ -247,7 +251,8 @@
   return 0;
 }
 
-int V4L2Wrapper::SetControl(uint32_t control_id, int32_t desired,
+int V4L2Wrapper::SetControl(uint32_t control_id,
+                            int32_t desired,
                             int32_t* result) {
   HAL_LOG_ENTER();
 
@@ -280,8 +285,8 @@
   }
 
   if (errno != EINVAL) {
-    HAL_LOGE("ENUM_FMT fails at index %d: %s", format_query.index,
-             strerror(errno));
+    HAL_LOGE(
+        "ENUM_FMT fails at index %d: %s", format_query.index, strerror(errno));
     return -ENODEV;
   }
   return 0;
@@ -308,7 +313,8 @@
       ++size_query.index;
     } while (IoctlLocked(VIDIOC_ENUM_FRAMESIZES, &size_query) >= 0);
     if (errno != EINVAL) {
-      HAL_LOGE("ENUM_FRAMESIZES fails at index %d: %s", size_query.index,
+      HAL_LOGE("ENUM_FRAMESIZES fails at index %d: %s",
+               size_query.index,
                strerror(errno));
       return -ENODEV;
     }
@@ -326,12 +332,16 @@
       if (desired_width < size_query.stepwise.min_width ||
           desired_height < size_query.stepwise.min_height) {
         HAL_LOGV("Standard size %u x %u is too small for format %d",
-                 desired_width, desired_height, v4l2_format);
+                 desired_width,
+                 desired_height,
+                 v4l2_format);
         continue;
       } else if (desired_width > size_query.stepwise.max_width &&
                  desired_height > size_query.stepwise.max_height) {
         HAL_LOGV("Standard size %u x %u is too big for format %d",
-                 desired_width, desired_height, v4l2_format);
+                 desired_width,
+                 desired_height,
+                 v4l2_format);
         continue;
       }
 
@@ -359,7 +369,8 @@
 }
 
 int V4L2Wrapper::GetFormatFrameDurationRange(
-    uint32_t v4l2_format, const std::array<int32_t, 2>& size,
+    uint32_t v4l2_format,
+    const std::array<int32_t, 2>& size,
     std::array<int64_t, 2>* duration_range) {
   // Potentially called so many times logging entry is a bad idea.
 
@@ -384,7 +395,8 @@
     } while (IoctlLocked(VIDIOC_ENUM_FRAMEINTERVALS, &duration_query) >= 0);
     if (errno != EINVAL) {
       HAL_LOGE("ENUM_FRAMEINTERVALS fails at index %d: %s",
-               duration_query.index, strerror(errno));
+               duration_query.index,
+               strerror(errno));
       return -ENODEV;
     }
   } else {
diff --git a/modules/camera/3_4/v4l2_wrapper.h b/modules/camera/3_4/v4l2_wrapper.h
index f2f08b3..3798c14 100644
--- a/modules/camera/3_4/v4l2_wrapper.h
+++ b/modules/camera/3_4/v4l2_wrapper.h
@@ -44,7 +44,8 @@
     Connection(std::shared_ptr<V4L2Wrapper> device)
         : device_(std::move(device)), connect_result_(device_->Connect()) {}
     ~Connection() {
-      if (connect_result_ == 0) device_->Disconnect();
+      if (connect_result_ == 0)
+        device_->Disconnect();
     }
     // Check whether the connection succeeded or not.
     inline int status() const { return connect_result_; }
@@ -60,7 +61,8 @@
   // Manage controls.
   virtual int QueryControl(uint32_t control_id, v4l2_query_ext_ctrl* result);
   virtual int GetControl(uint32_t control_id, int32_t* value);
-  virtual int SetControl(uint32_t control_id, int32_t desired,
+  virtual int SetControl(uint32_t control_id,
+                         int32_t desired,
                          int32_t* result = nullptr);
   // Manage format.
   virtual int GetFormats(std::set<uint32_t>* v4l2_formats);
@@ -68,7 +70,8 @@
                                   std::set<std::array<int32_t, 2>>* sizes);
   // Durations are returned in ns.
   virtual int GetFormatFrameDurationRange(
-      uint32_t v4l2_format, const std::array<int32_t, 2>& size,
+      uint32_t v4l2_format,
+      const std::array<int32_t, 2>& size,
       std::array<int64_t, 2>* duration_range);
   virtual int SetFormat(const default_camera_hal::Stream& stream,
                         uint32_t* result_max_buffers);
diff --git a/modules/camera/3_4/v4l2_wrapper_mock.h b/modules/camera/3_4/v4l2_wrapper_mock.h
index 1c3d27b..c717d32 100644
--- a/modules/camera/3_4/v4l2_wrapper_mock.h
+++ b/modules/camera/3_4/v4l2_wrapper_mock.h
@@ -39,10 +39,12 @@
   MOCK_METHOD2(GetFormatFrameSizes,
                int(uint32_t, std::set<std::array<int32_t, 2>>*));
   MOCK_METHOD3(GetFormatFrameDurationRange,
-               int(uint32_t, const std::array<int32_t, 2>&,
+               int(uint32_t,
+                   const std::array<int32_t, 2>&,
                    std::array<int64_t, 2>*));
-  MOCK_METHOD2(SetFormat, int(const default_camera_hal::Stream& stream,
-                              uint32_t* result_max_buffers));
+  MOCK_METHOD2(SetFormat,
+               int(const default_camera_hal::Stream& stream,
+                   uint32_t* result_max_buffers));
   MOCK_METHOD1(EnqueueBuffer,
                int(const camera3_stream_buffer_t* camera_buffer));
   MOCK_METHOD1(DequeueBuffer, int(v4l2_buffer* buffer));