diff --git a/src/base/memory/raw_scoped_refptr_mismatch_checker.h b/src/base/memory/raw_scoped_refptr_mismatch_checker.h
index 4309849..95b9c11 100644
--- a/src/base/memory/raw_scoped_refptr_mismatch_checker.h
+++ b/src/base/memory/raw_scoped_refptr_mismatch_checker.h
@@ -41,7 +41,7 @@
     // raw pointer type and are convertible to a RefCounted(Base|ThreadSafeBase)
     // type.
     value = std::is_pointer<T>::value &&
-            IsRefCountedType<std::remove_pointer_t<T>>::value
+    IsRefCountedType<std::remove_pointer_t<T>>::value
   };
 };
 
diff --git a/src/gn/command_suggest_unittest.cc b/src/gn/command_suggest_unittest.cc
index 1d02934..7367309 100644
--- a/src/gn/command_suggest_unittest.cc
+++ b/src/gn/command_suggest_unittest.cc
@@ -260,7 +260,7 @@
         {
             {&simple_secondary, commands::ApiScope::kPublic},
             {&simple_default, commands::ApiScope::kPublic},
-        };
+    };
     EXPECT_TRUE(ok);
     EXPECT_EQ(expected_targets, results);
   }
