diff --git a/runtime/gc/accounting/mod_union_table.cc b/runtime/gc/accounting/mod_union_table.cc
index b9e8925..b5ab3d9 100644
--- a/runtime/gc/accounting/mod_union_table.cc
+++ b/runtime/gc/accounting/mod_union_table.cc
@@ -54,8 +54,7 @@
 
 class ModUnionAddToCardBitmapVisitor {
  public:
-  explicit ModUnionAddToCardBitmapVisitor(ModUnionTable::CardBitmap* bitmap,
-                                          CardTable* card_table)
+  ModUnionAddToCardBitmapVisitor(ModUnionTable::CardBitmap* bitmap, CardTable* card_table)
       : bitmap_(bitmap), card_table_(card_table) {
   }
 
@@ -175,9 +174,9 @@
 
 class AddToReferenceArrayVisitor {
  public:
-  explicit AddToReferenceArrayVisitor(ModUnionTableReferenceCache* mod_union_table,
-                                      std::vector<mirror::HeapReference<Object>*>* references)
-    : mod_union_table_(mod_union_table), references_(references) {
+  AddToReferenceArrayVisitor(ModUnionTableReferenceCache* mod_union_table,
+                             std::vector<mirror::HeapReference<Object>*>* references)
+      : mod_union_table_(mod_union_table), references_(references) {
   }
 
   // Extra parameters are required since we use this same visitor signature for checking objects.
@@ -211,10 +210,10 @@
 
 class ModUnionReferenceVisitor {
  public:
-  explicit ModUnionReferenceVisitor(ModUnionTableReferenceCache* const mod_union_table,
-                                    std::vector<mirror::HeapReference<Object>*>* references)
-    : mod_union_table_(mod_union_table),
-      references_(references) {
+  ModUnionReferenceVisitor(ModUnionTableReferenceCache* const mod_union_table,
+                           std::vector<mirror::HeapReference<Object>*>* references)
+      : mod_union_table_(mod_union_table),
+        references_(references) {
   }
 
   void operator()(Object* obj) const
@@ -231,10 +230,10 @@
 
 class CheckReferenceVisitor {
  public:
-  explicit CheckReferenceVisitor(ModUnionTableReferenceCache* mod_union_table,
-                                 const std::set<const Object*>& references)
-    : mod_union_table_(mod_union_table),
-      references_(references) {
+  CheckReferenceVisitor(ModUnionTableReferenceCache* mod_union_table,
+                        const std::set<const Object*>& references)
+      : mod_union_table_(mod_union_table),
+        references_(references) {
   }
 
   // Extra parameters are required since we use this same visitor signature for checking objects.
@@ -277,8 +276,8 @@
 
 class ModUnionCheckReferences {
  public:
-  explicit ModUnionCheckReferences(ModUnionTableReferenceCache* mod_union_table,
-                                   const std::set<const Object*>& references)
+  ModUnionCheckReferences(ModUnionTableReferenceCache* mod_union_table,
+                          const std::set<const Object*>& references)
       REQUIRES(Locks::heap_bitmap_lock_)
       : mod_union_table_(mod_union_table), references_(references) {
   }
diff --git a/runtime/gc/collector/concurrent_copying.cc b/runtime/gc/collector/concurrent_copying.cc
index 8e329d6..220c06e 100644
--- a/runtime/gc/collector/concurrent_copying.cc
+++ b/runtime/gc/collector/concurrent_copying.cc
@@ -181,7 +181,7 @@
 // Used to switch the thread roots of a thread from from-space refs to to-space refs.
 class ThreadFlipVisitor : public Closure {
  public:
-  explicit ThreadFlipVisitor(ConcurrentCopying* concurrent_copying, bool use_tlab)
+  ThreadFlipVisitor(ConcurrentCopying* concurrent_copying, bool use_tlab)
       : concurrent_copying_(concurrent_copying), use_tlab_(use_tlab) {
   }
 
@@ -817,8 +817,8 @@
 
 class RevokeThreadLocalMarkStackCheckpoint : public Closure {
  public:
-  explicit RevokeThreadLocalMarkStackCheckpoint(ConcurrentCopying* concurrent_copying,
-                                                bool disable_weak_ref_access)
+  RevokeThreadLocalMarkStackCheckpoint(ConcurrentCopying* concurrent_copying,
+                                       bool disable_weak_ref_access)
       : concurrent_copying_(concurrent_copying),
         disable_weak_ref_access_(disable_weak_ref_access) {
   }
diff --git a/runtime/gc/collector/mark_sweep.cc b/runtime/gc/collector/mark_sweep.cc
index e2bcca2..3b6d2aa 100644
--- a/runtime/gc/collector/mark_sweep.cc
+++ b/runtime/gc/collector/mark_sweep.cc
@@ -648,8 +648,8 @@
  protected:
   class MarkObjectParallelVisitor {
    public:
-    ALWAYS_INLINE explicit MarkObjectParallelVisitor(MarkStackTask<kUseFinger>* chunk_task,
-                                                     MarkSweep* mark_sweep)
+    ALWAYS_INLINE MarkObjectParallelVisitor(MarkStackTask<kUseFinger>* chunk_task,
+                                            MarkSweep* mark_sweep)
         : chunk_task_(chunk_task), mark_sweep_(mark_sweep) {}
 
     void operator()(mirror::Object* obj, MemberOffset offset, bool /* static */) const
@@ -1058,8 +1058,8 @@
 
 class CheckpointMarkThreadRoots : public Closure, public RootVisitor {
  public:
-  explicit CheckpointMarkThreadRoots(MarkSweep* mark_sweep,
-                                     bool revoke_ros_alloc_thread_local_buffers_at_checkpoint)
+  CheckpointMarkThreadRoots(MarkSweep* mark_sweep,
+                            bool revoke_ros_alloc_thread_local_buffers_at_checkpoint)
       : mark_sweep_(mark_sweep),
         revoke_ros_alloc_thread_local_buffers_at_checkpoint_(
             revoke_ros_alloc_thread_local_buffers_at_checkpoint) {
diff --git a/runtime/gc/collector/mark_sweep.h b/runtime/gc/collector/mark_sweep.h
index 606be63..8bd1dc7 100644
--- a/runtime/gc/collector/mark_sweep.h
+++ b/runtime/gc/collector/mark_sweep.h
@@ -54,7 +54,7 @@
 
 class MarkSweep : public GarbageCollector {
  public:
-  explicit MarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
+  MarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
 
   ~MarkSweep() {}
 
diff --git a/runtime/gc/collector/partial_mark_sweep.h b/runtime/gc/collector/partial_mark_sweep.h
index 7b69bce..e9b4f6f 100644
--- a/runtime/gc/collector/partial_mark_sweep.h
+++ b/runtime/gc/collector/partial_mark_sweep.h
@@ -30,7 +30,7 @@
     return kGcTypePartial;
   }
 
-  explicit PartialMarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
+  PartialMarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
   ~PartialMarkSweep() {}
 
  protected:
diff --git a/runtime/gc/collector/sticky_mark_sweep.h b/runtime/gc/collector/sticky_mark_sweep.h
index e8e70de..e8f0672 100644
--- a/runtime/gc/collector/sticky_mark_sweep.h
+++ b/runtime/gc/collector/sticky_mark_sweep.h
@@ -30,7 +30,7 @@
     return kGcTypeSticky;
   }
 
-  explicit StickyMarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
+  StickyMarkSweep(Heap* heap, bool is_concurrent, const std::string& name_prefix = "");
   ~StickyMarkSweep() {}
 
  protected:
diff --git a/runtime/gc/heap.cc b/runtime/gc/heap.cc
index 141fed2..89773ce 100644
--- a/runtime/gc/heap.cc
+++ b/runtime/gc/heap.cc
@@ -2108,7 +2108,7 @@
 // Special compacting collector which uses sub-optimal bin packing to reduce zygote space size.
 class ZygoteCompactingCollector FINAL : public collector::SemiSpace {
  public:
-  explicit ZygoteCompactingCollector(gc::Heap* heap, bool is_running_on_memory_tool)
+  ZygoteCompactingCollector(gc::Heap* heap, bool is_running_on_memory_tool)
       : SemiSpace(heap, false, "zygote collector"),
         bin_live_bitmap_(nullptr),
         bin_mark_bitmap_(nullptr),
@@ -2634,7 +2634,7 @@
 // Verify a reference from an object.
 class VerifyReferenceVisitor : public SingleRootVisitor {
  public:
-  explicit VerifyReferenceVisitor(Heap* heap, Atomic<size_t>* fail_count, bool verify_referent)
+  VerifyReferenceVisitor(Heap* heap, Atomic<size_t>* fail_count, bool verify_referent)
       SHARED_REQUIRES(Locks::mutator_lock_, Locks::heap_bitmap_lock_)
       : heap_(heap), fail_count_(fail_count), verify_referent_(verify_referent) {}
 
@@ -2784,7 +2784,7 @@
 // Verify all references within an object, for use with HeapBitmap::Visit.
 class VerifyObjectVisitor {
  public:
-  explicit VerifyObjectVisitor(Heap* heap, Atomic<size_t>* fail_count, bool verify_referent)
+  VerifyObjectVisitor(Heap* heap, Atomic<size_t>* fail_count, bool verify_referent)
       : heap_(heap), fail_count_(fail_count), verify_referent_(verify_referent) {}
 
   void operator()(mirror::Object* obj)
@@ -3453,8 +3453,8 @@
 
 class Heap::ConcurrentGCTask : public HeapTask {
  public:
-  explicit ConcurrentGCTask(uint64_t target_time, bool force_full)
-    : HeapTask(target_time), force_full_(force_full) { }
+  ConcurrentGCTask(uint64_t target_time, bool force_full)
+      : HeapTask(target_time), force_full_(force_full) { }
   virtual void Run(Thread* self) OVERRIDE {
     gc::Heap* heap = Runtime::Current()->GetHeap();
     heap->ConcurrentGC(self, force_full_);
diff --git a/runtime/gc/heap.h b/runtime/gc/heap.h
index 6676049..055095d 100644
--- a/runtime/gc/heap.h
+++ b/runtime/gc/heap.h
@@ -161,36 +161,36 @@
   // Create a heap with the requested sizes. The possible empty
   // image_file_names names specify Spaces to load based on
   // ImageWriter output.
-  explicit Heap(size_t initial_size,
-                size_t growth_limit,
-                size_t min_free,
-                size_t max_free,
-                double target_utilization,
-                double foreground_heap_growth_multiplier,
-                size_t capacity,
-                size_t non_moving_space_capacity,
-                const std::string& original_image_file_name,
-                InstructionSet image_instruction_set,
-                CollectorType foreground_collector_type,
-                CollectorType background_collector_type,
-                space::LargeObjectSpaceType large_object_space_type,
-                size_t large_object_threshold,
-                size_t parallel_gc_threads,
-                size_t conc_gc_threads,
-                bool low_memory_mode,
-                size_t long_pause_threshold,
-                size_t long_gc_threshold,
-                bool ignore_max_footprint,
-                bool use_tlab,
-                bool verify_pre_gc_heap,
-                bool verify_pre_sweeping_heap,
-                bool verify_post_gc_heap,
-                bool verify_pre_gc_rosalloc,
-                bool verify_pre_sweeping_rosalloc,
-                bool verify_post_gc_rosalloc,
-                bool gc_stress_mode,
-                bool use_homogeneous_space_compaction,
-                uint64_t min_interval_homogeneous_space_compaction_by_oom);
+  Heap(size_t initial_size,
+       size_t growth_limit,
+       size_t min_free,
+       size_t max_free,
+       double target_utilization,
+       double foreground_heap_growth_multiplier,
+       size_t capacity,
+       size_t non_moving_space_capacity,
+       const std::string& original_image_file_name,
+       InstructionSet image_instruction_set,
+       CollectorType foreground_collector_type,
+       CollectorType background_collector_type,
+       space::LargeObjectSpaceType large_object_space_type,
+       size_t large_object_threshold,
+       size_t parallel_gc_threads,
+       size_t conc_gc_threads,
+       bool low_memory_mode,
+       size_t long_pause_threshold,
+       size_t long_gc_threshold,
+       bool ignore_max_footprint,
+       bool use_tlab,
+       bool verify_pre_gc_heap,
+       bool verify_pre_sweeping_heap,
+       bool verify_post_gc_heap,
+       bool verify_pre_gc_rosalloc,
+       bool verify_pre_sweeping_rosalloc,
+       bool verify_post_gc_rosalloc,
+       bool gc_stress_mode,
+       bool use_homogeneous_space_compaction,
+       uint64_t min_interval_homogeneous_space_compaction_by_oom);
 
   ~Heap();
 
diff --git a/runtime/gc/space/memory_tool_malloc_space.h b/runtime/gc/space/memory_tool_malloc_space.h
index fe39e05..a5dbad9 100644
--- a/runtime/gc/space/memory_tool_malloc_space.h
+++ b/runtime/gc/space/memory_tool_malloc_space.h
@@ -55,7 +55,7 @@
   size_t MaxBytesBulkAllocatedFor(size_t num_bytes) OVERRIDE;
 
   template <typename... Params>
-  explicit MemoryToolMallocSpace(MemMap* mem_map, size_t initial_size, Params... params);
+  MemoryToolMallocSpace(MemMap* mem_map, size_t initial_size, Params... params);
   virtual ~MemoryToolMallocSpace() {}
 
  private:
diff --git a/runtime/gc/task_processor_test.cc b/runtime/gc/task_processor_test.cc
index f06f68d..2c44da2 100644
--- a/runtime/gc/task_processor_test.cc
+++ b/runtime/gc/task_processor_test.cc
@@ -102,7 +102,7 @@
 
 class TestOrderTask : public HeapTask {
  public:
-  explicit TestOrderTask(uint64_t expected_time, size_t expected_counter, size_t* counter)
+  TestOrderTask(uint64_t expected_time, size_t expected_counter, size_t* counter)
      : HeapTask(expected_time), expected_counter_(expected_counter), counter_(counter) {
   }
   virtual void Run(Thread* thread) OVERRIDE {