Clean up dead code in dex2oat resulting from ignoring --compact-dex-level.

The flag has been ignored since https://r.android.com/2736873.

Also clean up the associated build variable
ART_DEFAULT_COMPACT_DEX_LEVEL which was only allowed to be "none".

The build depedencies and dexlayout itself will be removed in later CLs.

Test: art/tools/buildbot-build.sh
Bug: 325430813
Change-Id: I0feae2121c11901e0676e26b5ec67c7745c6edf5

11 files changed, 45 insertions, 195 deletions

diff --git a/build/Android.common_build.mk b/build/Android.common_build.mk
index 08962526dd..f5a95fa0cf 100644
--- a/build/Android.common_build.mk
+++ b/build/Android.common_build.mk
@@ -49,11 +49,6 @@ endif
 # Enable the read barrier by default.
 ART_USE_READ_BARRIER ?= true
 
-# Default compact dex level to none.
-ifeq ($(ART_DEFAULT_COMPACT_DEX_LEVEL),)
-ART_DEFAULT_COMPACT_DEX_LEVEL := none
-endif
-
 ART_CPP_EXTENSION := .cc
 
 ifndef LIBART_IMG_HOST_BASE_ADDRESS
diff --git a/dex2oat/dex2oat.cc b/dex2oat/dex2oat.cc
index 9529e6d28b..45e6ae1052 100644
--- a/dex2oat/dex2oat.cc
+++ b/dex2oat/dex2oat.cc
@@ -78,7 +78,6 @@
 #include "dex/quick_compiler_callbacks.h"
 #include "dex/verification_results.h"
 #include "dex2oat_options.h"
-#include "dexlayout.h"
 #include "driver/compiler_driver.h"
 #include "driver/compiler_options.h"
 #include "driver/compiler_options_map-inl.h"
@@ -1060,9 +1059,10 @@ class Dex2Oat final {
 
     M& args = *args_uptr;
 
+    std::string compact_dex_level;
     std::unique_ptr<ParserOptions> parser_options(new ParserOptions());
 
-    AssignIfExists(args, M::CompactDexLevel, &compact_dex_level_);
+    AssignIfExists(args, M::CompactDexLevel, &compact_dex_level);
     AssignIfExists(args, M::DexFiles, &dex_filenames_);
     AssignIfExists(args, M::DexLocations, &dex_locations_);
     AssignIfExists(args, M::DexFds, &dex_fds_);
@@ -1112,9 +1112,8 @@ class Dex2Oat final {
     AssignIfExists(args, M::PublicSdk, &public_sdk_);
     AssignIfExists(args, M::ApexVersions, &apex_versions_argument_);
 
-    if (compact_dex_level_ != CompactDexLevel::kCompactDexLevelNone) {
+    if (!compact_dex_level.empty()) {
       LOG(WARNING) << "Obsolete flag --compact-dex-level ignored";
-      compact_dex_level_ = CompactDexLevel::kCompactDexLevelNone;
     }
 
     AssignIfExists(args, M::TargetInstructionSet, &compiler_options_->instruction_set_);
@@ -1228,12 +1227,6 @@ class Dex2Oat final {
       thread_count_ = 1;
     }
 
-    // For debuggable apps, we do not want to generate compact dex as class
-    // redefinition will want a proper dex file.
-    if (compiler_options_->GetDebuggable()) {
-      compact_dex_level_ = CompactDexLevel::kCompactDexLevelNone;
-    }
-
     PaletteShouldReportDex2oatCompilation(&should_report_dex2oat_compilation_);
     AssignTrueIfExists(args, M::ForcePaletteCompilationHooks, &should_report_dex2oat_compilation_);
 
@@ -2349,18 +2342,6 @@ class Dex2Oat final {
     return profile_compilation_info_ != nullptr && !profile_compilation_info_->IsEmpty();
   }
 
-  bool DoGenerateCompactDex() const {
-    return compact_dex_level_ != CompactDexLevel::kCompactDexLevelNone;
-  }
-
-  bool DoDexLayoutOptimizations() const {
-    // Only run dexlayout when being asked to generate compact dex. We do this
-    // to avoid having multiple arguments being passed to dex2oat and the main
-    // user of dex2oat (installd) will have the same reasons for
-    // disabling/enabling compact dex and dex layout.
-    return DoGenerateCompactDex();
-  }
-
   bool DoOatLayoutOptimizations() const {
     return DoProfileGuidedOptimizations();
   }
@@ -2655,13 +2636,12 @@ class Dex2Oat final {
     for (const std::unique_ptr<File>& oat_file : oat_files_) {
       elf_writers_.emplace_back(linker::CreateElfWriterQuick(*compiler_options_, oat_file.get()));
       elf_writers_.back()->Start();
-      bool do_oat_writer_layout = DoDexLayoutOptimizations() || DoOatLayoutOptimizations();
+      bool do_oat_writer_layout = DoOatLayoutOptimizations();
       oat_writers_.emplace_back(new linker::OatWriter(
           *compiler_options_,
           verification_results_.get(),
           timings_,
-          do_oat_writer_layout ? profile_compilation_info_.get() : nullptr,
-          compact_dex_level_));
+          do_oat_writer_layout ? profile_compilation_info_.get() : nullptr));
     }
   }
 
@@ -2968,9 +2948,6 @@ class Dex2Oat final {
   std::string no_inline_from_string_;
   bool force_allow_oj_inlines_ = false;
 
-  // TODO(b/256664509): Clean this up.
-  CompactDexLevel compact_dex_level_ = CompactDexLevel::kCompactDexLevelNone;
-
   std::vector<std::unique_ptr<linker::ElfWriter>> elf_writers_;
   std::vector<std::unique_ptr<linker::OatWriter>> oat_writers_;
   std::vector<OutputStream*> rodata_;
diff --git a/dex2oat/dex2oat_options.cc b/dex2oat/dex2oat_options.cc
index adeecccc5e..34a72f084e 100644
--- a/dex2oat/dex2oat_options.cc
+++ b/dex2oat/dex2oat_options.cc
@@ -417,11 +417,9 @@ Parser CreateDex2oatArgumentParser() {
                     "\n"
                     "Example: --class-loader-context=PCL[lib1.dex:lib2.dex];DLC[lib3.dex]")
           .IntoKey(M::StoredClassLoaderContext)
+      // TODO(b/325430813): Obsolete argument that only prints a warning if used. Delete altogether.
       .Define("--compact-dex-level=_")
-          .WithType<CompactDexLevel>()
-          .WithValueMap({{"none", CompactDexLevel::kCompactDexLevelNone},
-                         {"fast", CompactDexLevel::kCompactDexLevelFast}})
-          .WithHelp("This flag is obsolete and does nothing.")
+          .WithType<std::string>()
           .IntoKey(M::CompactDexLevel)
       .Define("--runtime-arg _")
           .WithType<std::vector<std::string>>().AppendValues()
diff --git a/dex2oat/dex2oat_options.def b/dex2oat/dex2oat_options.def
index 9a05d2b4df..7cf9d023b7 100644
--- a/dex2oat/dex2oat_options.def
+++ b/dex2oat/dex2oat_options.def
@@ -34,7 +34,7 @@
 //
 
 // Parse-able keys from the command line.
-DEX2OAT_OPTIONS_KEY (CompactDexLevel,                CompactDexLevel)
+DEX2OAT_OPTIONS_KEY (std::string,                    CompactDexLevel)
 DEX2OAT_OPTIONS_KEY (std::vector<std::string>,       DexFiles)
 DEX2OAT_OPTIONS_KEY (std::vector<std::string>,       DexLocations)
 DEX2OAT_OPTIONS_KEY (std::vector<int>,               DexFds)
diff --git a/dex2oat/dex2oat_options.h b/dex2oat/dex2oat_options.h
index ef07512f51..ce496e9fb3 100644
--- a/dex2oat/dex2oat_options.h
+++ b/dex2oat/dex2oat_options.h
@@ -25,7 +25,6 @@
 #include "base/variant_map.h"
 #include "cmdline_types.h"  // TODO: don't need to include this file here
 #include "compiler.h"
-#include "dex/compact_dex_level.h"
 #include "driver/compiler_options_map.h"
 #include "linker/oat_writer.h"
 #include "oat/image.h"
diff --git a/dex2oat/linker/image_test.h b/dex2oat/linker/image_test.h
index f4a87bb84d..71e7f4de19 100644
--- a/dex2oat/linker/image_test.h
+++ b/dex2oat/linker/image_test.h
@@ -247,8 +247,7 @@ inline void ImageTest::DoCompile(ImageHeader::StorageMode storage_mode,
         oat_writers.emplace_back(new OatWriter(*compiler_options_,
                                                verification_results_.get(),
                                                &timings,
-                                               /*profile_compilation_info*/nullptr,
-                                               CompactDexLevel::kCompactDexLevelNone));
+                                               /*profile_compilation_info*/nullptr));
       }
 
       std::vector<OutputStream*> rodata;
diff --git a/dex2oat/linker/oat_writer.cc b/dex2oat/linker/oat_writer.cc
index 1419338066..78b3f972f1 100644
--- a/dex2oat/linker/oat_writer.cc
+++ b/dex2oat/linker/oat_writer.cc
@@ -51,8 +51,6 @@
 #include "dex/standard_dex_file.h"
 #include "dex/type_lookup_table.h"
 #include "dex/verification_results.h"
-#include "dex_container.h"
-#include "dexlayout.h"
 #include "driver/compiled_method-inl.h"
 #include "driver/compiler_driver-inl.h"
 #include "driver/compiler_options.h"
@@ -287,10 +285,7 @@ class OatWriter::OatDexFile {
   std::unique_ptr<const DexFile> dex_file_;
   std::unique_ptr<std::string> dex_file_location_;
 
-  std::vector<uint8_t> cdex_main_section_;
-
-  // Dex file size. Passed in the constructor, but could be
-  // overwritten by LayoutDexFile.
+  // Dex file size. Passed in the constructor.
   size_t dex_file_size_;
 
   // Offset of start of OatDexFile from beginning of OatHeader. It is
@@ -351,8 +346,7 @@ class OatWriter::OatDexFile {
 OatWriter::OatWriter(const CompilerOptions& compiler_options,
                      const VerificationResults* verification_results,
                      TimingLogger* timings,
-                     ProfileCompilationInfo* info,
-                     CompactDexLevel compact_dex_level)
+                     ProfileCompilationInfo* info)
     : write_state_(WriteState::kAddingDexFileSources),
       timings_(timings),
       compiler_driver_(nullptr),
@@ -390,8 +384,7 @@ OatWriter::OatWriter(const CompilerOptions& compiler_options,
       oat_data_offset_(0u),
       oat_header_(nullptr),
       relative_patcher_(nullptr),
-      profile_compilation_info_(info),
-      compact_dex_level_(compact_dex_level) {}
+      profile_compilation_info_(info) {}
 
 static bool ValidateDexFileHeader(const uint8_t* raw_header, const char* location) {
   const bool valid_standard_dex_magic = DexFileLoader::IsMagicValid(raw_header);
@@ -3296,31 +3289,9 @@ bool OatWriter::WriteDexFiles(File* file,
     }
   }
 
-  // Compact dex reader/writer does not understand dex containers,
-  // which is ok since dex containers replace compat-dex.
-  for (OatDexFile& oat_dex_file : oat_dex_files_) {
-    const DexFile* dex_file = oat_dex_file.GetDexFile();
-    if (dex_file->HasDexContainer()) {
-      compact_dex_level_ = CompactDexLevel::kCompactDexLevelNone;
-    }
-  }
-
   if (extract_dex_files_into_vdex_) {
     vdex_dex_files_offset_ = vdex_size_;
 
-    // Perform dexlayout if compact dex is enabled. Also see
-    // Dex2Oat::DoDexLayoutOptimizations.
-    if (compact_dex_level_ != CompactDexLevel::kCompactDexLevelNone) {
-      for (OatDexFile& oat_dex_file : oat_dex_files_) {
-        // use_existing_vdex should not be used with compact dex and layout.
-        CHECK(!use_existing_vdex)
-            << "We should never update the input vdex when doing dexlayout or compact dex";
-        if (!LayoutDexFile(&oat_dex_file)) {
-          return false;
-        }
-      }
-    }
-
     // Calculate the total size after the dex files.
     size_t vdex_size_with_dex_files = vdex_size_;
     for (OatDexFile& oat_dex_file : oat_dex_files_) {
@@ -3339,31 +3310,27 @@ bool OatWriter::WriteDexFiles(File* file,
     // Add the shared data section size.
     const uint8_t* raw_dex_file_shared_data_begin = nullptr;
     uint32_t shared_data_size = 0u;
-    if (dex_container_ != nullptr) {
-      shared_data_size = dex_container_->GetDataSection()->Size();
-    } else {
-      // Dex files from input vdex are represented as raw dex files and they can be
-      // compact dex files. These need to specify the same shared data section if any.
-      for (const OatDexFile& oat_dex_file : oat_dex_files_) {
-        const DexFile* dex_file = oat_dex_file.GetDexFile();
-        auto& header = dex_file->GetHeader();
-        if (!dex_file->IsCompactDexFile() || header.data_size_ == 0u) {
-          // Non compact dex does not have shared data section.
-          continue;
-        }
-        const uint8_t* cur_data_begin = dex_file->Begin() + header.data_off_;
-        if (raw_dex_file_shared_data_begin == nullptr) {
-          raw_dex_file_shared_data_begin = cur_data_begin;
-        } else if (raw_dex_file_shared_data_begin != cur_data_begin) {
-          LOG(ERROR) << "Mismatched shared data sections in raw dex files: "
-                     << static_cast<const void*>(raw_dex_file_shared_data_begin)
-                     << " != " << static_cast<const void*>(cur_data_begin);
-          return false;
-        }
-        // The different dex files currently can have different data sizes since
-        // the dex writer writes them one at a time into the shared section.:w
-        shared_data_size = std::max(shared_data_size, header.data_size_);
+    // Dex files from input vdex are represented as raw dex files and they can be
+    // compact dex files. These need to specify the same shared data section if any.
+    for (const OatDexFile& oat_dex_file : oat_dex_files_) {
+      const DexFile* dex_file = oat_dex_file.GetDexFile();
+      auto& header = dex_file->GetHeader();
+      if (!dex_file->IsCompactDexFile() || header.data_size_ == 0u) {
+        // Non compact dex does not have shared data section.
+        continue;
       }
+      const uint8_t* cur_data_begin = dex_file->Begin() + header.data_off_;
+      if (raw_dex_file_shared_data_begin == nullptr) {
+        raw_dex_file_shared_data_begin = cur_data_begin;
+      } else if (raw_dex_file_shared_data_begin != cur_data_begin) {
+        LOG(ERROR) << "Mismatched shared data sections in raw dex files: "
+                   << static_cast<const void*>(raw_dex_file_shared_data_begin)
+                   << " != " << static_cast<const void*>(cur_data_begin);
+        return false;
+      }
+      // The different dex files currently can have different data sizes since
+      // the dex writer writes them one at a time into the shared section.:w
+      shared_data_size = std::max(shared_data_size, header.data_size_);
     }
     if (shared_data_size != 0u) {
       // Shared data section is required to be 4 byte aligned.
@@ -3412,21 +3379,13 @@ bool OatWriter::WriteDexFiles(File* file,
       // Write the actual dex file.
       DCHECK_EQ(vdex_size_, oat_dex_file.dex_file_offset_);
       uint8_t* out = vdex_begin_ + oat_dex_file.dex_file_offset_;
-      const std::vector<uint8_t>& cdex_data = oat_dex_file.cdex_main_section_;
-      if (!cdex_data.empty()) {
-        CHECK(!use_existing_vdex);
-        // Use the compact dex version instead of the original dex file.
-        DCHECK_EQ(oat_dex_file.dex_file_size_, cdex_data.size());
-        memcpy(out, cdex_data.data(), cdex_data.size());
+      const DexFile* dex_file = oat_dex_file.GetDexFile();
+      DCHECK_EQ(oat_dex_file.dex_file_size_, dex_file->Size());
+      if (use_existing_vdex) {
+        // The vdex already contains the data.
+        DCHECK_EQ(memcmp(out, dex_file->Begin(), dex_file->Size()), 0);
       } else {
-        const DexFile* dex_file = oat_dex_file.GetDexFile();
-        DCHECK_EQ(oat_dex_file.dex_file_size_, dex_file->Size());
-        if (use_existing_vdex) {
-          // The vdex already contains the data.
-          DCHECK_EQ(memcmp(out, dex_file->Begin(), dex_file->Size()), 0);
-        } else {
-          memcpy(out, dex_file->Begin(), dex_file->Size());
-        }
+        memcpy(out, dex_file->Begin(), dex_file->Size());
       }
 
       // Update current size and account for the written data.
@@ -3443,15 +3402,7 @@ bool OatWriter::WriteDexFiles(File* file,
       size_dex_file_alignment_ += vdex_dex_shared_data_offset_ - vdex_size_;
       vdex_size_ = vdex_dex_shared_data_offset_;
 
-      if (dex_container_ != nullptr) {
-        CHECK(!use_existing_vdex) << "Use existing vdex should have empty dex container";
-        CHECK(compact_dex_level_ != CompactDexLevel::kCompactDexLevelNone);
-        DexContainer::Section* const section = dex_container_->GetDataSection();
-        DCHECK_EQ(shared_data_size, section->Size());
-        memcpy(vdex_begin_ + vdex_size_, section->Begin(), shared_data_size);
-        section->Clear();
-        dex_container_.reset();
-      } else if (!use_existing_vdex) {
+      if (!use_existing_vdex) {
         memcpy(vdex_begin_ + vdex_size_, raw_dex_file_shared_data_begin, shared_data_size);
       }
       vdex_size_ += shared_data_size;
@@ -3495,43 +3446,6 @@ void OatWriter::CloseSources() {
   }
 }
 
-bool OatWriter::LayoutDexFile(OatDexFile* oat_dex_file) {
-  TimingLogger::ScopedTiming split("Dex Layout", timings_);
-  std::string error_msg;
-  std::string location(oat_dex_file->GetLocation());
-  std::unique_ptr<const DexFile>& dex_file = oat_dex_file->dex_file_;
-  Options options;
-  options.compact_dex_level_ = compact_dex_level_;
-  options.update_checksum_ = true;
-  DexLayout dex_layout(options, profile_compilation_info_, /*file*/ nullptr, /*header*/ nullptr);
-  {
-    TimingLogger::ScopedTiming extract("ProcessDexFile", timings_);
-    if (dex_layout.ProcessDexFile(location.c_str(),
-                                  dex_file.get(),
-                                  0,
-                                  &dex_container_,
-                                  &error_msg)) {
-      oat_dex_file->dex_sections_layout_ = dex_layout.GetSections();
-      oat_dex_file->cdex_main_section_ = dex_container_->GetMainSection()->ReleaseData();
-      // Dex layout can affect the size of the dex file, so we update here what we have set
-      // when adding the dex file as a source.
-      const UnalignedDexFileHeader* header =
-          AsUnalignedDexFileHeader(oat_dex_file->cdex_main_section_.data());
-      oat_dex_file->dex_file_size_ = header->file_size_;
-    } else {
-      LOG(WARNING) << "Failed to run dex layout, reason:" << error_msg;
-      // Since we failed to convert the dex, just copy the input dex.
-      if (dex_container_ != nullptr) {
-        // Clear the main section before processing next dex file in case we have written some data.
-        dex_container_->GetMainSection()->Clear();
-      }
-    }
-  }
-  CHECK_EQ(oat_dex_file->dex_file_location_checksum_, dex_file->GetLocationChecksum());
-  CHECK(oat_dex_file->dex_file_sha1_ == dex_file->GetSha1());
-  return true;
-}
-
 bool OatWriter::OpenDexFiles(
     File* file,
     /*inout*/ std::vector<MemMap>* opened_dex_files_map,
diff --git a/dex2oat/linker/oat_writer.h b/dex2oat/linker/oat_writer.h
index dc441a11d8..6cd9a7f71c 100644
--- a/dex2oat/linker/oat_writer.h
+++ b/dex2oat/linker/oat_writer.h
@@ -29,7 +29,6 @@
 #include "base/mem_map.h"
 #include "base/safe_map.h"
 #include "debug/debug_info.h"
-#include "dex/compact_dex_level.h"
 #include "dex/method_reference.h"
 #include "dex/string_reference.h"
 #include "dex/proto_reference.h"
@@ -43,7 +42,6 @@ class BitVector;
 class CompiledMethod;
 class CompilerDriver;
 class CompilerOptions;
-class DexContainer;
 class OatHeader;
 class OutputStream;
 class ProfileCompilationInfo;
@@ -119,8 +117,7 @@ class OatWriter {
   OatWriter(const CompilerOptions& compiler_options,
             const VerificationResults* verification_results,
             TimingLogger* timings,
-            ProfileCompilationInfo* info,
-            CompactDexLevel compact_dex_level);
+            ProfileCompilationInfo* info);
 
   // To produce a valid oat file, the user must first add sources with any combination of
   //   - AddDexFileSource(),
@@ -592,9 +589,6 @@ class OatWriter {
   // Profile info used to generate new layout of files.
   ProfileCompilationInfo* profile_compilation_info_;
 
-  // Compact dex level that is generated.
-  CompactDexLevel compact_dex_level_;
-
   using OrderedMethodList = std::vector<OrderedMethodData>;
 
   // List of compiled methods, sorted by the order defined in OrderedMethodData.
@@ -602,9 +596,6 @@ class OatWriter {
   // This pointer is only non-null after InitOatCodeDexFiles succeeds.
   std::unique_ptr<OrderedMethodList> ordered_methods_;
 
-  // Container of shared dex data.
-  std::unique_ptr<DexContainer> dex_container_;
-
   DISALLOW_COPY_AND_ASSIGN(OatWriter);
 };
 
diff --git a/dex2oat/linker/oat_writer_test.cc b/dex2oat/linker/oat_writer_test.cc
index f2a6ee47f0..4bcf29804c 100644
--- a/dex2oat/linker/oat_writer_test.cc
+++ b/dex2oat/linker/oat_writer_test.cc
@@ -109,8 +109,7 @@ class OatTest : public CommonCompilerDriverTest {
     OatWriter oat_writer(*compiler_options_,
                          verification_results_.get(),
                          &timings,
-                         /*profile_compilation_info*/nullptr,
-                         CompactDexLevel::kCompactDexLevelNone);
+                         /*profile_compilation_info*/nullptr);
     for (const DexFile* dex_file : dex_files) {
       if (!oat_writer.AddRawDexFileSource(dex_file->GetContainer(),
                                           dex_file->Begin(),
@@ -135,8 +134,7 @@ class OatTest : public CommonCompilerDriverTest {
     OatWriter oat_writer(*compiler_options_,
                          verification_results_.get(),
                          &timings,
-                         profile_compilation_info,
-                         CompactDexLevel::kCompactDexLevelNone);
+                         profile_compilation_info);
     for (const char* dex_filename : dex_filenames) {
       if (!oat_writer.AddDexFileSource(dex_filename, dex_filename)) {
         return false;
@@ -158,8 +156,7 @@ class OatTest : public CommonCompilerDriverTest {
     OatWriter oat_writer(*compiler_options_,
                          verification_results_.get(),
                          &timings,
-                         profile_compilation_info,
-                         CompactDexLevel::kCompactDexLevelNone);
+                         profile_compilation_info);
     if (!oat_writer.AddDexFileSource(std::move(dex_file_fd), location)) {
       return false;
     }
diff --git a/libdexfile/dex/compact_dex_level.h b/libdexfile/dex/compact_dex_level.h
index 2f06688e8e..e6b5446b5f 100644
--- a/libdexfile/dex/compact_dex_level.h
+++ b/libdexfile/dex/compact_dex_level.h
@@ -17,10 +17,6 @@
 #ifndef ART_LIBDEXFILE_DEX_COMPACT_DEX_LEVEL_H_
 #define ART_LIBDEXFILE_DEX_COMPACT_DEX_LEVEL_H_
 
-#include <string>
-
-#include "dex_file.h"
-
 namespace art {
 
 // Optimization level for compact dex generation.
@@ -32,18 +28,6 @@ enum class CompactDexLevel {
   kCompactDexLevelFast,
 };
 
-#ifdef ART_DEFAULT_COMPACT_DEX_LEVEL
-#define ART_DEFAULT_COMPACT_DEX_LEVEL_VALUE_fast CompactDexLevel::kCompactDexLevelFast
-#define ART_DEFAULT_COMPACT_DEX_LEVEL_VALUE_none CompactDexLevel::kCompactDexLevelNone
-
-#define ART_DEFAULT_COMPACT_DEX_LEVEL_DEFAULT APPEND_TOKENS_AFTER_EVAL( \
-    ART_DEFAULT_COMPACT_DEX_LEVEL_VALUE_, \
-    ART_DEFAULT_COMPACT_DEX_LEVEL)
-
-static_assert(ART_DEFAULT_COMPACT_DEX_LEVEL_DEFAULT == CompactDexLevel::kCompactDexLevelNone,
-              "ART_DEFAULT_COMPACT_DEX_LEVEL_DEFAULT != none is no longer supported");
-#endif
-
 }  // namespace art
 
 #endif  // ART_LIBDEXFILE_DEX_COMPACT_DEX_LEVEL_H_
diff --git a/test/testrunner/target_config.py b/test/testrunner/target_config.py
index 38c170df97..7b2ac54262 100644
--- a/test/testrunner/target_config.py
+++ b/test/testrunner/target_config.py
@@ -164,9 +164,7 @@ target_config = {
                       '--cdex-none'],
         'env' : {
             'ART_USE_READ_BARRIER' : 'false',
-            'ART_HEAP_POISONING' : 'true',
-            # Disable compact dex to get coverage of standard dex file usage.
-            'ART_DEFAULT_COMPACT_DEX_LEVEL' : 'none'
+            'ART_HEAP_POISONING' : 'true'
         }
     },
     'art-preopt' : {
@@ -204,9 +202,7 @@ target_config = {
         'make' :  'test-art-host-gtest',
         'env': {
             'ART_DEFAULT_GC_TYPE' : 'SS',
-            'ART_USE_READ_BARRIER' : 'false',
-            # Disable compact dex to get coverage of standard dex file usage.
-            'ART_DEFAULT_COMPACT_DEX_LEVEL' : 'none'
+            'ART_USE_READ_BARRIER' : 'false'
         }
     },
     # TODO: Consider removing this configuration when it is no longer used by