diff --git a/cmds/dumpstate/bugreport-format.md b/cmds/dumpstate/bugreport-format.md
index c33fc1f..388b506 100644
--- a/cmds/dumpstate/bugreport-format.md
+++ b/cmds/dumpstate/bugreport-format.md
@@ -63,8 +63,8 @@
 For example, the initial version during _Android N_ development was
 **1.0-dev1**. When `dumpsys` was split in 2 sections but not all tools were
 ready to parse that format, the version was named **1.0-dev2**,
-which had to be passed do `dumpsys` explicitly (i.e., trhough a
-`-V 1.0-dev2` argument). Once that format became stable and tools
+which had to be passed to `dumpsys` explicitly (by setting the `dumpstate.version` system property).
+Once that format became stable and tools
 knew how to parse it, the default version became **1.0-dev2**.
 
 Similarly, if changes in the file format are made after the initial release of
diff --git a/cmds/dumpstate/dumpstate.cpp b/cmds/dumpstate/dumpstate.cpp
index 7a0e89b..29589cd 100644
--- a/cmds/dumpstate/dumpstate.cpp
+++ b/cmds/dumpstate/dumpstate.cpp
@@ -111,6 +111,7 @@
 
 static constexpr char PROPERTY_EXTRA_OPTIONS[] = "dumpstate.options";
 static constexpr char PROPERTY_LAST_ID[] = "dumpstate.last_id";
+static constexpr char PROPERTY_VERSION[] = "dumpstate.version";
 
 /* gets the tombstone data, according to the bugreport type: if zipped, gets all tombstones;
  * otherwise, gets just those modified in the last half an hour. */
@@ -161,7 +162,7 @@
     if (!ds.IsZipping()) return;
     std::string title = "MOUNT INFO";
     mount_points.clear();
-    DurationReporter durationReporter(title, nullptr);
+    DurationReporter duration_reporter(title, nullptr);
     for_each_pid(do_mountinfo, nullptr);
     MYLOGD("%s: %d entries added to zip file\n", title.c_str(), (int)mount_points.size());
 }
@@ -612,8 +613,8 @@
     JustDumpFile("", "/proc/version");
     printf("Command line: %s\n", strtok(cmdline_buf, "\n"));
     printf("Bugreport format version: %s\n", version_.c_str());
-    printf("Dumpstate info: id=%lu pid=%d dryRun=%d args=%s extraOptions=%s\n", id_, getpid(),
-           dryRun_, args_.c_str(), extraOptions_.c_str());
+    printf("Dumpstate info: id=%lu pid=%d dry_run=%d args=%s extra_options=%s\n", id_, getpid(),
+           dry_run_, args_.c_str(), extra_options_.c_str());
     printf("\n");
 }
 
@@ -705,7 +706,7 @@
         return;
     }
     MYLOGD("Adding dir %s (recursive: %d)\n", dir.c_str(), recursive);
-    DurationReporter durationReporter(dir, nullptr);
+    DurationReporter duration_reporter(dir, nullptr);
     dump_files("", dir.c_str(), recursive ? skip_none : is_dir, _add_file_from_fd);
 }
 
@@ -751,7 +752,7 @@
 }
 
 static void dumpstate() {
-    DurationReporter durationReporter("DUMPSTATE");
+    DurationReporter duration_reporter("DUMPSTATE");
     unsigned long timeout;
 
     dump_dev_files("TRUSTY VERSION", "/sys/bus/platform/drivers/trusty", "trusty_version");
@@ -797,7 +798,7 @@
     /* Dump Bluetooth HCI logs */
     ds.AddDir("/data/misc/bluetooth/logs", true);
 
-    if (!ds.doEarlyScreenshot_) {
+    if (!ds.do_early_screenshot_) {
         MYLOGI("taking late screenshot\n");
         ds.TakeScreenshot();
     }
@@ -1038,7 +1039,7 @@
 
     printf("========================================================\n");
     printf("== Final progress (pid %d): %d/%d (originally %d)\n", getpid(), ds.progress_,
-           ds.weightTotal_, WEIGHT_TOTAL);
+           ds.weight_total_, WEIGHT_TOTAL);
     printf("========================================================\n");
     printf("== dumpstate: done (id %lu)\n", ds.id_);
     printf("========================================================\n");
@@ -1063,8 +1064,7 @@
             "progress (requires -o and -B)\n"
             "  -R: take bugreport in remote mode (requires -o, -z, -d and -B, "
             "shouldn't be used with -P)\n"
-            "  -V: sets the bugreport format version (valid values: %s)\n",
-            VERSION_DEFAULT.c_str());
+            "  -v: prints the dumpstate header and exit\n");
     exit(exitCode);
 }
 
@@ -1099,9 +1099,9 @@
 }
 
 bool Dumpstate::FinishZipFile() {
-    std::string entry_name = baseName_ + "-" + name_ + ".txt";
+    std::string entry_name = base_name_ + "-" + name_ + ".txt";
     MYLOGD("Adding main entry (%s) from %s to .zip bugreport\n", entry_name.c_str(),
-           tmp_path.c_str());
+           tmp_path_.c_str());
     // Final timestamp
     char date[80];
     time_t the_real_now_please_stand_up = time(nullptr);
@@ -1109,7 +1109,7 @@
     MYLOGD("dumpstate id %lu finished around %s (%ld s)\n", ds.id_, date,
            the_real_now_please_stand_up - ds.now_);
 
-    if (!ds.AddZipEntry(entry_name, tmp_path)) {
+    if (!ds.AddZipEntry(entry_name, tmp_path_)) {
         MYLOGE("Failed to add text entry to .zip file\n");
         return false;
     }
@@ -1120,12 +1120,12 @@
 
     // Add log file (which contains stderr output) to zip...
     fprintf(stderr, "dumpstate_log.txt entry on zip file logged up to here\n");
-    if (!ds.AddZipEntry("dumpstate_log.txt", ds.log_path.c_str())) {
+    if (!ds.AddZipEntry("dumpstate_log.txt", ds.log_path_.c_str())) {
         MYLOGE("Failed to add dumpstate log to .zip file\n");
         return false;
     }
     // ... and re-opens it for further logging.
-    redirect_to_existing_file(stderr, const_cast<char*>(ds.log_path.c_str()));
+    redirect_to_existing_file(stderr, const_cast<char*>(ds.log_path_.c_str()));
     fprintf(stderr, "\n");
 
     int32_t err = zip_writer->Finish();
@@ -1138,12 +1138,12 @@
     ds.zip_file.reset(nullptr);
 
     if (IsUserBuild()) {
-        MYLOGD("Removing temporary file %s\n", tmp_path.c_str())
-        if (remove(tmp_path.c_str()) != 0) {
-            ALOGW("remove(%s): %s\n", tmp_path.c_str(), strerror(errno));
+        MYLOGD("Removing temporary file %s\n", tmp_path_.c_str())
+        if (remove(tmp_path_.c_str()) != 0) {
+            ALOGW("remove(%s): %s\n", tmp_path_.c_str(), strerror(errno));
         }
     } else {
-        MYLOGD("Keeping temporary file %s on non-user build\n", tmp_path.c_str())
+        MYLOGD("Keeping temporary file %s on non-user build\n", tmp_path_.c_str())
     }
 
     return true;
@@ -1194,42 +1194,12 @@
     int do_fb = 0;
     int do_broadcast = 0;
     int is_remote_mode = 0;
-
-    MYLOGI("begin\n");
-
-    if (acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME) < 0) {
-        MYLOGE("Failed to acquire wake lock: %s \n", strerror(errno));
-    } else {
-        MYLOGD("Wake lock acquired.\n");
-        atexit(wake_lock_releaser);
-        register_sig_handler();
-    }
-
-    if (ds.IsDryRun()) {
-        MYLOGI("Running on dry-run mode (to disable it, call 'setprop dumpstate.dry_run false')\n");
-    }
-
-    // TODO: use helper function to convert argv into a string
-    for (int i = 0; i < argc; i++) {
-        ds.args_ += argv[i];
-        if (i < argc - 1) {
-            ds.args_ += " ";
-        }
-    }
-
-    ds.extraOptions_ = android::base::GetProperty(PROPERTY_EXTRA_OPTIONS, "");
-    MYLOGI("Dumpstate args: %s (extra options: %s)\n", ds.args_.c_str(), ds.extraOptions_.c_str());
-
-    /* gets the sequential id */
-    int lastId = android::base::GetIntProperty(PROPERTY_LAST_ID, 0);
-    ds.id_ = ++lastId;
-    android::base::SetProperty(PROPERTY_LAST_ID, std::to_string(lastId));
-    MYLOGI("dumpstate id: %lu\n", ds.id_);
+    bool show_header_only = false;
 
     /* set as high priority, and protect from OOM killer */
     setpriority(PRIO_PROCESS, 0, -20);
 
-    FILE *oom_adj = fopen("/proc/self/oom_score_adj", "we");
+    FILE* oom_adj = fopen("/proc/self/oom_score_adj", "we");
     if (oom_adj) {
         fputs("-1000", oom_adj);
         fclose(oom_adj);
@@ -1247,18 +1217,18 @@
     while ((c = getopt(argc, argv, "dho:svqzpPBRSV:")) != -1) {
         switch (c) {
             // clang-format off
-            case 'd': do_add_date = 1;           break;
-            case 'z': do_zip_file = 1;           break;
-            case 'o': use_outfile = optarg;      break;
-            case 's': use_socket = 1;            break;
-            case 'S': use_control_socket = 1;    break;
-            case 'v':                            break;  // compatibility no-op
-            case 'q': do_vibrate = 0;            break;
-            case 'p': do_fb = 1;                 break;
-            case 'P': ds.updateProgress_ = true; break;
-            case 'R': is_remote_mode = 1;        break;
-            case 'B': do_broadcast = 1;          break;
-            case 'V': ds.version_ = optarg;      break;
+            case 'd': do_add_date = 1;            break;
+            case 'z': do_zip_file = 1;            break;
+            case 'o': use_outfile = optarg;       break;
+            case 's': use_socket = 1;             break;
+            case 'S': use_control_socket = 1;     break;
+            case 'v': show_header_only = true;    break;
+            case 'q': do_vibrate = 0;             break;
+            case 'p': do_fb = 1;                  break;
+            case 'P': ds.update_progress_ = true; break;
+            case 'R': is_remote_mode = 1;         break;
+            case 'B': do_broadcast = 1;           break;
+            case 'V':                             break; // compatibility no-op
             case 'h':
                 ShowUsageAndExit(0);
                 break;
@@ -1269,29 +1239,35 @@
         }
     }
 
-    if (!ds.extraOptions_.empty()) {
+    // TODO: use helper function to convert argv into a string
+    for (int i = 0; i < argc; i++) {
+        ds.args_ += argv[i];
+        if (i < argc - 1) {
+            ds.args_ += " ";
+        }
+    }
+
+    ds.extra_options_ = android::base::GetProperty(PROPERTY_EXTRA_OPTIONS, "");
+    if (!ds.extra_options_.empty()) {
         // Framework uses a system property to override some command-line args.
         // Currently, it contains the type of the requested bugreport.
-        if (ds.extraOptions_ == "bugreportplus") {
-            MYLOGD("Running as bugreportplus: add -P, remove -p\n");
-            ds.updateProgress_ = true;
+        if (ds.extra_options_ == "bugreportplus") {
+            ds.update_progress_ = true;
             do_fb = 0;
-        } else if (ds.extraOptions_ == "bugreportremote") {
-            MYLOGD("Running as bugreportremote: add -q -R, remove -p\n");
+        } else if (ds.extra_options_ == "bugreportremote") {
             do_vibrate = 0;
             is_remote_mode = 1;
             do_fb = 0;
-        } else if (ds.extraOptions_ == "bugreportwear") {
-            MYLOGD("Running as bugreportwear: add -P\n");
-            ds.updateProgress_ = true;
+        } else if (ds.extra_options_ == "bugreportwear") {
+            ds.update_progress_ = true;
         } else {
-            MYLOGE("Unknown extra option: %s\n", ds.extraOptions_.c_str());
+            MYLOGE("Unknown extra option: %s\n", ds.extra_options_.c_str());
         }
         // Reset the property
         android::base::SetProperty(PROPERTY_EXTRA_OPTIONS, "");
     }
 
-    if ((do_zip_file || do_add_date || ds.updateProgress_ || do_broadcast) && !use_outfile) {
+    if ((do_zip_file || do_add_date || ds.update_progress_ || do_broadcast) && !use_outfile) {
         ExitOnInvalidArgs();
     }
 
@@ -1299,21 +1275,54 @@
         ExitOnInvalidArgs();
     }
 
-    if (ds.updateProgress_ && !do_broadcast) {
+    if (ds.update_progress_ && !do_broadcast) {
         ExitOnInvalidArgs();
     }
 
-    if (is_remote_mode && (ds.updateProgress_ || !do_broadcast || !do_zip_file || !do_add_date)) {
+    if (is_remote_mode && (ds.update_progress_ || !do_broadcast || !do_zip_file || !do_add_date)) {
         ExitOnInvalidArgs();
     }
 
-    if (ds.version_ != VERSION_DEFAULT) {
-        ShowUsageAndExit();
+    if (ds.version_ == VERSION_DEFAULT) {
+        ds.version_ = VERSION_CURRENT;
     }
 
+    if (ds.version_ != VERSION_CURRENT) {
+        MYLOGE("invalid version requested ('%s'); suppported values are: ('%s', '%s')\n",
+               ds.version_.c_str(), VERSION_DEFAULT.c_str(), VERSION_CURRENT.c_str());
+        exit(1);
+    }
+
+    if (show_header_only) {
+        ds.PrintHeader();
+        exit(0);
+    }
+
+    /* gets the sequential id */
+    int last_id = android::base::GetIntProperty(PROPERTY_LAST_ID, 0);
+    ds.id_ = ++last_id;
+    android::base::SetProperty(PROPERTY_LAST_ID, std::to_string(last_id));
+
+    MYLOGI("begin\n");
+
+    if (acquire_wake_lock(PARTIAL_WAKE_LOCK, WAKE_LOCK_NAME) < 0) {
+        MYLOGE("Failed to acquire wake lock: %s \n", strerror(errno));
+    } else {
+        MYLOGD("Wake lock acquired.\n");
+        atexit(wake_lock_releaser);
+        register_sig_handler();
+    }
+
+    if (ds.IsDryRun()) {
+        MYLOGI("Running on dry-run mode (to disable it, call 'setprop dumpstate.dry_run false')\n");
+    }
+
+    MYLOGI("dumpstate info: id=%lu, args='%s', extra_options= %s)\n", ds.id_, ds.args_.c_str(),
+           ds.extra_options_.c_str());
+
     MYLOGI("bugreport format version: %s\n", ds.version_.c_str());
 
-    ds.doEarlyScreenshot_ = ds.updateProgress_;
+    ds.do_early_screenshot_ = ds.update_progress_;
 
     // If we are going to use a socket, do it as early as possible
     // to avoid timeouts from bugreport.
@@ -1323,16 +1332,16 @@
 
     if (use_control_socket) {
         MYLOGD("Opening control socket\n");
-        ds.controlSocketFd_ = open_socket("dumpstate");
-        ds.updateProgress_ = 1;
+        ds.control_socket_fd_ = open_socket("dumpstate");
+        ds.update_progress_ = 1;
     }
 
     /* redirect output if needed */
     bool is_redirecting = !use_socket && use_outfile;
 
     if (is_redirecting) {
-        ds.bugreportDir_ = dirname(use_outfile);
-        ds.baseName_ = basename(use_outfile);
+        ds.bugreport_dir_ = dirname(use_outfile);
+        ds.base_name_ = basename(use_outfile);
         if (do_add_date) {
             char date[80];
             strftime(date, sizeof(date), "%Y-%m-%d-%H-%M-%S", localtime(&ds.now_));
@@ -1341,12 +1350,12 @@
             ds.name_ = "undated";
         }
         std::string buildId = android::base::GetProperty("ro.build.id", "UNKNOWN_BUILD");
-        ds.baseName_ = ds.baseName_ + "-" + buildId;
+        ds.base_name_ += "-" + buildId;
         if (do_fb) {
-            ds.screenshotPath_ = ds.GetPath(".png");
+            ds.screenshot_path_ = ds.GetPath(".png");
         }
-        ds.tmp_path = ds.GetPath(".tmp");
-        ds.log_path = ds.GetPath("-dumpstate_log-" + std::to_string(getpid()) + ".txt");
+        ds.tmp_path_ = ds.GetPath(".tmp");
+        ds.log_path_ = ds.GetPath("-dumpstate_log-" + std::to_string(getpid()) + ".txt");
 
         MYLOGD(
             "Bugreport dir: %s\n"
@@ -1355,16 +1364,16 @@
             "Log path: %s\n"
             "Temporary path: %s\n"
             "Screenshot path: %s\n",
-            ds.bugreportDir_.c_str(), ds.baseName_.c_str(), ds.name_.c_str(), ds.log_path.c_str(),
-            ds.tmp_path.c_str(), ds.screenshotPath_.c_str());
+            ds.bugreport_dir_.c_str(), ds.base_name_.c_str(), ds.name_.c_str(),
+            ds.log_path_.c_str(), ds.tmp_path_.c_str(), ds.screenshot_path_.c_str());
 
         if (do_zip_file) {
-            ds.path = ds.GetPath(".zip");
-            MYLOGD("Creating initial .zip file (%s)\n", ds.path.c_str());
-            create_parent_dirs(ds.path.c_str());
-            ds.zip_file.reset(fopen(ds.path.c_str(), "wb"));
+            ds.path_ = ds.GetPath(".zip");
+            MYLOGD("Creating initial .zip file (%s)\n", ds.path_.c_str());
+            create_parent_dirs(ds.path_.c_str());
+            ds.zip_file.reset(fopen(ds.path_.c_str(), "wb"));
             if (ds.zip_file == nullptr) {
-                MYLOGE("fopen(%s, 'wb'): %s\n", ds.path.c_str(), strerror(errno));
+                MYLOGE("fopen(%s, 'wb'): %s\n", ds.path_.c_str(), strerror(errno));
                 do_zip_file = 0;
             } else {
                 zip_writer.reset(new ZipWriter(ds.zip_file.get()));
@@ -1372,7 +1381,7 @@
             ds.AddTextZipEntry("version.txt", ds.version_);
         }
 
-        if (ds.updateProgress_) {
+        if (ds.update_progress_) {
             if (do_broadcast) {
                 // clang-format off
                 std::vector<std::string> am_args = {
@@ -1386,7 +1395,7 @@
                 send_broadcast("android.intent.action.BUGREPORT_STARTED", am_args);
             }
             if (use_control_socket) {
-                dprintf(ds.controlSocketFd_, "BEGIN:%s\n", ds.path.c_str());
+                dprintf(ds.control_socket_fd_, "BEGIN:%s\n", ds.path_.c_str());
             }
         }
     }
@@ -1407,8 +1416,8 @@
         }
     }
 
-    if (do_fb && ds.doEarlyScreenshot_) {
-        if (ds.screenshotPath_.empty()) {
+    if (do_fb && ds.do_early_screenshot_) {
+        if (ds.screenshot_path_.empty()) {
             // should not have happened
             MYLOGE("INTERNAL ERROR: skipping early screenshot because path was not set\n");
         } else {
@@ -1418,25 +1427,25 @@
     }
 
     if (do_zip_file) {
-        if (chown(ds.path.c_str(), AID_SHELL, AID_SHELL)) {
-            MYLOGE("Unable to change ownership of zip file %s: %s\n", ds.path.c_str(),
+        if (chown(ds.path_.c_str(), AID_SHELL, AID_SHELL)) {
+            MYLOGE("Unable to change ownership of zip file %s: %s\n", ds.path_.c_str(),
                    strerror(errno));
         }
     }
 
     if (is_redirecting) {
-        redirect_to_file(stderr, const_cast<char*>(ds.log_path.c_str()));
-        if (chown(ds.log_path.c_str(), AID_SHELL, AID_SHELL)) {
-            MYLOGE("Unable to change ownership of dumpstate log file %s: %s\n", ds.log_path.c_str(),
-                   strerror(errno));
+        redirect_to_file(stderr, const_cast<char*>(ds.log_path_.c_str()));
+        if (chown(ds.log_path_.c_str(), AID_SHELL, AID_SHELL)) {
+            MYLOGE("Unable to change ownership of dumpstate log file %s: %s\n",
+                   ds.log_path_.c_str(), strerror(errno));
         }
         /* TODO: rather than generating a text file now and zipping it later,
            it would be more efficient to redirect stdout to the zip entry
            directly, but the libziparchive doesn't support that option yet. */
-        redirect_to_file(stdout, const_cast<char*>(ds.tmp_path.c_str()));
-        if (chown(ds.tmp_path.c_str(), AID_SHELL, AID_SHELL)) {
+        redirect_to_file(stdout, const_cast<char*>(ds.tmp_path_.c_str()));
+        if (chown(ds.tmp_path_.c_str(), AID_SHELL, AID_SHELL)) {
             MYLOGE("Unable to change ownership of temporary bugreport file %s: %s\n",
-                   ds.tmp_path.c_str(), strerror(errno));
+                   ds.tmp_path_.c_str(), strerror(errno));
         }
     }
     // NOTE: there should be no stdout output until now, otherwise it would break the header.
@@ -1513,13 +1522,13 @@
         if (change_suffix) {
             MYLOGI("changing suffix from %s to %s\n", ds.name_.c_str(), name.c_str());
             ds.name_ = name;
-            if (!ds.screenshotPath_.empty()) {
-                std::string newScreenshotPath = ds.GetPath(".png");
-                if (rename(ds.screenshotPath_.c_str(), newScreenshotPath.c_str())) {
-                    MYLOGE("rename(%s, %s): %s\n", ds.screenshotPath_.c_str(),
-                           newScreenshotPath.c_str(), strerror(errno));
+            if (!ds.screenshot_path_.empty()) {
+                std::string new_screenshot_path = ds.GetPath(".png");
+                if (rename(ds.screenshot_path_.c_str(), new_screenshot_path.c_str())) {
+                    MYLOGE("rename(%s, %s): %s\n", ds.screenshot_path_.c_str(),
+                           new_screenshot_path.c_str(), strerror(errno));
                 } else {
-                    ds.screenshotPath_ = newScreenshotPath;
+                    ds.screenshot_path_ = new_screenshot_path;
                 }
             }
         }
@@ -1532,36 +1541,36 @@
             } else {
                 do_text_file = false;
                 // Since zip file is already created, it needs to be renamed.
-                std::string newPath = ds.GetPath(".zip");
-                if (ds.path != newPath) {
-                    MYLOGD("Renaming zip file from %s to %s\n", ds.path.c_str(), newPath.c_str());
-                    if (rename(ds.path.c_str(), newPath.c_str())) {
-                        MYLOGE("rename(%s, %s): %s\n", ds.path.c_str(), newPath.c_str(),
+                std::string new_path = ds.GetPath(".zip");
+                if (ds.path_ != new_path) {
+                    MYLOGD("Renaming zip file from %s to %s\n", ds.path_.c_str(), new_path.c_str());
+                    if (rename(ds.path_.c_str(), new_path.c_str())) {
+                        MYLOGE("rename(%s, %s): %s\n", ds.path_.c_str(), new_path.c_str(),
                                strerror(errno));
                     } else {
-                        ds.path = newPath;
+                        ds.path_ = new_path;
                     }
                 }
             }
         }
         if (do_text_file) {
-            ds.path = ds.GetPath(".txt");
-            MYLOGD("Generating .txt bugreport at %s from %s\n", ds.path.c_str(),
-                   ds.tmp_path.c_str());
-            if (rename(ds.tmp_path.c_str(), ds.path.c_str())) {
-                MYLOGE("rename(%s, %s): %s\n", ds.tmp_path.c_str(), ds.path.c_str(),
+            ds.path_ = ds.GetPath(".txt");
+            MYLOGD("Generating .txt bugreport at %s from %s\n", ds.path_.c_str(),
+                   ds.tmp_path_.c_str());
+            if (rename(ds.tmp_path_.c_str(), ds.path_.c_str())) {
+                MYLOGE("rename(%s, %s): %s\n", ds.tmp_path_.c_str(), ds.path_.c_str(),
                        strerror(errno));
-                ds.path.clear();
+                ds.path_.clear();
             }
         }
         if (use_control_socket) {
             if (do_text_file) {
-                dprintf(ds.controlSocketFd_,
+                dprintf(ds.control_socket_fd_,
                         "FAIL:could not create zip file, check %s "
                         "for more details\n",
-                        ds.log_path.c_str());
+                        ds.log_path_.c_str());
             } else {
-                dprintf(ds.controlSocketFd_, "OK:%s\n", ds.path.c_str());
+                dprintf(ds.control_socket_fd_, "OK:%s\n", ds.path_.c_str());
             }
         }
     }
@@ -1576,27 +1585,27 @@
 
     /* tell activity manager we're done */
     if (do_broadcast) {
-        if (!ds.path.empty()) {
-            MYLOGI("Final bugreport path: %s\n", ds.path.c_str());
+        if (!ds.path_.empty()) {
+            MYLOGI("Final bugreport path: %s\n", ds.path_.c_str());
             // clang-format off
             std::vector<std::string> am_args = {
                  "--receiver-permission", "android.permission.DUMP", "--receiver-foreground",
                  "--ei", "android.intent.extra.ID", std::to_string(ds.id_),
                  "--ei", "android.intent.extra.PID", std::to_string(getpid()),
-                 "--ei", "android.intent.extra.MAX", std::to_string(ds.weightTotal_),
-                 "--es", "android.intent.extra.BUGREPORT", ds.path,
-                 "--es", "android.intent.extra.DUMPSTATE_LOG", ds.log_path
+                 "--ei", "android.intent.extra.MAX", std::to_string(ds.weight_total_),
+                 "--es", "android.intent.extra.BUGREPORT", ds.path_,
+                 "--es", "android.intent.extra.DUMPSTATE_LOG", ds.log_path_
             };
             // clang-format on
             if (do_fb) {
                 am_args.push_back("--es");
                 am_args.push_back("android.intent.extra.SCREENSHOT");
-                am_args.push_back(ds.screenshotPath_);
+                am_args.push_back(ds.screenshot_path_);
             }
             if (is_remote_mode) {
                 am_args.push_back("--es");
                 am_args.push_back("android.intent.extra.REMOTE_BUGREPORT_HASH");
-                am_args.push_back(SHA256_file_hash(ds.path));
+                am_args.push_back(SHA256_file_hash(ds.path_));
                 send_broadcast("android.intent.action.REMOTE_BUGREPORT_FINISHED", am_args);
             } else {
                 send_broadcast("android.intent.action.BUGREPORT_FINISHED", am_args);
@@ -1606,16 +1615,16 @@
         }
     }
 
-    MYLOGD("Final progress: %d/%d (originally %d)\n", ds.progress_, ds.weightTotal_, WEIGHT_TOTAL);
+    MYLOGD("Final progress: %d/%d (originally %d)\n", ds.progress_, ds.weight_total_, WEIGHT_TOTAL);
     MYLOGI("done (id %lu)\n", ds.id_);
 
     if (is_redirecting) {
         fclose(stderr);
     }
 
-    if (use_control_socket && ds.controlSocketFd_ != -1) {
+    if (use_control_socket && ds.control_socket_fd_ != -1) {
         MYLOGD("Closing control socket\n");
-        close(ds.controlSocketFd_);
+        close(ds.control_socket_fd_);
     }
 
     return 0;
diff --git a/cmds/dumpstate/dumpstate.h b/cmds/dumpstate/dumpstate.h
index e7dd6e8..568256a 100644
--- a/cmds/dumpstate/dumpstate.h
+++ b/cmds/dumpstate/dumpstate.h
@@ -119,9 +119,9 @@
 
         long timeout_;
         bool always_;
-        RootMode rootMode_;
-        StdoutMode stdoutMode_;
-        std::string loggingMessage_;
+        RootMode root_mode_;
+        StdoutMode stdout_mode_;
+        std::string logging_message_;
 
         friend class CommandOptions;
         friend class CommandOptionsBuilder;
@@ -129,7 +129,7 @@
 
     CommandOptions(const CommandOptionsValues& values);
 
-    const CommandOptionsValues values_;
+    const CommandOptionsValues values;
 
   public:
     class CommandOptionsBuilder {
@@ -150,7 +150,7 @@
 
       private:
         CommandOptionsBuilder(long timeout);
-        CommandOptionsValues values_;
+        CommandOptionsValues values;
         friend class CommandOptions;
     };
 
@@ -197,7 +197,12 @@
  *
  * See bugreport-format.md for more info.
  */
-static std::string VERSION_DEFAULT = "1.0";
+static std::string VERSION_CURRENT = "1.0";
+
+/*
+ * "Alias" for the current version.
+ */
+static std::string VERSION_DEFAULT = "default";
 
 /*
  * Main class driving a bugreport generation.
@@ -249,12 +254,12 @@
      * description).
      * |dumpsys_args| `dumpsys` arguments (except `-t`).
      * |options| optional argument defining the command's behavior.
-     * |dumpsysTimeout| when > 0, defines the value passed to `dumpsys -t` (otherwise it uses the
+     * |dumpsys_timeout| when > 0, defines the value passed to `dumpsys -t` (otherwise it uses the
      * timeout from `options`)
      */
-    void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsysArgs,
+    void RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args,
                     const CommandOptions& options = CommandOptions::DEFAULT_DUMPSYS,
-                    long dumpsysTimeout = 0);
+                    long dumpsys_timeout = 0);
 
     /*
      * Prints the contents of a file.
@@ -317,60 +322,61 @@
     unsigned long id_;
 
     // Whether progress updates should be published.
-    bool updateProgress_ = false;
+    bool update_progress_ = false;
 
     // Whether it should take an screenshot earlier in the process.
-    bool doEarlyScreenshot_ = false;
+    bool do_early_screenshot_ = false;
 
     // Currrent progress.
     int progress_ = 0;
 
     // Total estimated progress.
-    int weightTotal_ = WEIGHT_TOTAL;
+    int weight_total_ = WEIGHT_TOTAL;
 
     // When set, defines a socket file-descriptor use to report progress to bugreportz.
-    int controlSocketFd_ = -1;
+    int control_socket_fd_ = -1;
 
     // Bugreport format version;
-    std::string version_ = VERSION_DEFAULT;
+    std::string version_ = VERSION_CURRENT;
 
     // Command-line arguments as string
     std::string args_;
 
     // Extra options passed as system property.
-    std::string extraOptions_;
+    std::string extra_options_;
 
     // Full path of the directory where the bugreport files will be written.
-    std::string bugreportDir_;
+    std::string bugreport_dir_;
 
     // Full path of the temporary file containing the screenshot (when requested).
-    std::string screenshotPath_;
+    std::string screenshot_path_;
 
     time_t now_;
 
     // Base name (without suffix or extensions) of the bugreport files, typically
     // `bugreport-BUILD_ID`.
-    std::string baseName_;
+    std::string base_name_;
 
     // Name is the suffix part of the bugreport files - it's typically the date (when invoked with
     // `-d`), but it could be changed by the user..
     std::string name_;
 
     // Full path of the temporary file containing the bugreport.
-    std::string tmp_path;
+    std::string tmp_path_;
 
     // Full path of the file containing the dumpstate logs.
-    std::string log_path;
+    std::string log_path_;
 
     // Pointer to the actual path, be it zip or text.
-    std::string path;
+    std::string path_;
 
     // Pointer to the zipped file.
     std::unique_ptr<FILE, int (*)(FILE*)> zip_file{nullptr, fclose};
 
   private:
     // Used by GetInstance() only.
-    Dumpstate(bool dryRun = false, const std::string& buildType = "user");
+    Dumpstate(const std::string& version = VERSION_CURRENT, bool dry_run = false,
+              const std::string& build_type = "user");
 
     // Internal version of RunCommand that just runs it, without updating progress.
     int JustRunCommand(const char* command, const char* path, std::vector<const char*>& args,
@@ -380,10 +386,10 @@
     int JustDumpFile(const std::string& title, const std::string& path) const;
 
     // Whether this is a dry run.
-    bool dryRun_;
+    bool dry_run_;
 
     // Build type (such as 'user' or 'eng').
-    std::string buildType_;
+    std::string build_type_;
 };
 
 // for_each_pid_func = void (*)(int, const char*);
diff --git a/cmds/dumpstate/tests/dumpstate_test.cpp b/cmds/dumpstate/tests/dumpstate_test.cpp
index 8d70704..4073c3c 100644
--- a/cmds/dumpstate/tests/dumpstate_test.cpp
+++ b/cmds/dumpstate/tests/dumpstate_test.cpp
@@ -52,15 +52,15 @@
     void SetUp() {
         SetDryRun(false);
         SetBuildType(android::base::GetProperty("ro.build.type", "(unknown)"));
-        ds.updateProgress_ = false;
+        ds.update_progress_ = false;
     }
 
     // Runs a command and capture `stdout` and `stderr`.
-    int RunCommand(const std::string& title, const std::vector<std::string>& fullCommand,
+    int RunCommand(const std::string& title, const std::vector<std::string>& full_command,
                    const CommandOptions& options = CommandOptions::DEFAULT) {
         CaptureStdout();
         CaptureStderr();
-        int status = ds.RunCommand(title, fullCommand, options);
+        int status = ds.RunCommand(title, full_command, options);
         out = GetCapturedStdout();
         err = GetCapturedStderr();
         return status;
@@ -76,14 +76,14 @@
         return status;
     }
 
-    void SetDryRun(bool dryRun) {
-        ALOGD("Setting dryRun_ to %s\n", dryRun ? "true" : "false");
-        ds.dryRun_ = dryRun;
+    void SetDryRun(bool dry_run) {
+        ALOGD("Setting dry_run_ to %s\n", dry_run ? "true" : "false");
+        ds.dry_run_ = dry_run;
     }
 
-    void SetBuildType(const std::string& buildType) {
-        ALOGD("Setting buildType_ to '%s'\n", buildType.c_str());
-        ds.buildType_ = buildType;
+    void SetBuildType(const std::string& build_type) {
+        ALOGD("Setting build_type_ to '%s'\n", build_type.c_str());
+        ds.build_type_ = build_type;
     }
 
     bool IsUserBuild() {
@@ -97,41 +97,41 @@
     }
 
     // TODO: remove when progress is set by Binder callbacks.
-    void AssertSystemProperty(const std::string& key, const std::string& expectedValue) {
+    void AssertSystemProperty(const std::string& key, const std::string& expected_value) {
         std::string actualValue = android::base::GetProperty(key, "not set");
-        EXPECT_THAT(expectedValue, StrEq(actualValue)) << "invalid value for property " << key;
+        EXPECT_THAT(expected_value, StrEq(actualValue)) << "invalid value for property " << key;
     }
 
-    std::string GetProgressMessage(int progress, int weightTotal, int oldWeightTotal = 0) {
+    std::string GetProgressMessage(int progress, int weigh_total, int old_weigh_total = 0) {
         EXPECT_EQ(progress, ds.progress_) << "invalid progress";
-        EXPECT_EQ(weightTotal, ds.weightTotal_) << "invalid weightTotal";
+        EXPECT_EQ(weigh_total, ds.weight_total_) << "invalid weigh_total";
 
         AssertSystemProperty(android::base::StringPrintf("dumpstate.%d.progress", getpid()),
                              std::to_string(progress));
 
-        bool maxIncreased = oldWeightTotal > 0;
+        bool max_increased = old_weigh_total > 0;
 
-        std::string adjustmentMessage = "";
-        if (maxIncreased) {
+        std::string adjustment_message = "";
+        if (max_increased) {
             AssertSystemProperty(android::base::StringPrintf("dumpstate.%d.max", getpid()),
-                                 std::to_string(weightTotal));
-            adjustmentMessage = android::base::StringPrintf(
-                "Adjusting total weight from %d to %d\n", oldWeightTotal, weightTotal);
+                                 std::to_string(weigh_total));
+            adjustment_message = android::base::StringPrintf(
+                "Adjusting total weight from %d to %d\n", old_weigh_total, weigh_total);
         }
 
         return android::base::StringPrintf("%sSetting progress (dumpstate.%d.progress): %d/%d\n",
-                                           adjustmentMessage.c_str(), getpid(), progress,
-                                           weightTotal);
+                                           adjustment_message.c_str(), getpid(), progress,
+                                           weigh_total);
     }
 
     // `stdout` and `stderr` from the last command ran.
     std::string out, err;
 
-    std::string testPath = dirname(android::base::GetExecutablePath().c_str());
-    std::string fixturesPath = testPath + "/../dumpstate_test_fixture/";
-    std::string testDataPath = fixturesPath + "/testdata/";
-    std::string simpleCommand = fixturesPath + "dumpstate_test_fixture";
-    std::string echoCommand = "/system/bin/echo";
+    std::string test_path = dirname(android::base::GetExecutablePath().c_str());
+    std::string fixtures_path = test_path + "/../dumpstate_test_fixture/";
+    std::string test_data_path = fixtures_path + "/testdata/";
+    std::string simple_command = fixtures_path + "dumpstate_test_fixture";
+    std::string echo_command = "/system/bin/echo";
 
     Dumpstate& ds = Dumpstate::GetInstance();
 };
@@ -141,52 +141,52 @@
 }
 
 TEST_F(DumpstateTest, RunCommandNoTitle) {
-    EXPECT_EQ(0, RunCommand("", {simpleCommand}));
+    EXPECT_EQ(0, RunCommand("", {simple_command}));
     EXPECT_THAT(out, StrEq("stdout\n"));
     EXPECT_THAT(err, StrEq("stderr\n"));
 }
 
 TEST_F(DumpstateTest, RunCommandWithTitle) {
-    EXPECT_EQ(0, RunCommand("I AM GROOT", {simpleCommand}));
+    EXPECT_EQ(0, RunCommand("I AM GROOT", {simple_command}));
     EXPECT_THAT(err, StrEq("stderr\n"));
     // We don't know the exact duration, so we check the prefix and suffix
     EXPECT_THAT(out,
-                StartsWith("------ I AM GROOT (" + simpleCommand + ") ------\nstdout\n------"));
+                StartsWith("------ I AM GROOT (" + simple_command + ") ------\nstdout\n------"));
     EXPECT_THAT(out, EndsWith("s was the duration of 'I AM GROOT' ------\n"));
 }
 
 TEST_F(DumpstateTest, RunCommandWithLoggingMessage) {
     EXPECT_EQ(
-        0, RunCommand("", {simpleCommand},
+        0, RunCommand("", {simple_command},
                       CommandOptions::WithTimeout(10).Log("COMMAND, Y U NO LOG FIRST?").Build()));
     EXPECT_THAT(out, StrEq("stdout\n"));
     EXPECT_THAT(err, StrEq("COMMAND, Y U NO LOG FIRST?stderr\n"));
 }
 
 TEST_F(DumpstateTest, RunCommandRedirectStderr) {
-    EXPECT_EQ(0, RunCommand("", {simpleCommand},
+    EXPECT_EQ(0, RunCommand("", {simple_command},
                             CommandOptions::WithTimeout(10).RedirectStderr().Build()));
     EXPECT_THAT(out, IsEmpty());
     EXPECT_THAT(err, StrEq("stdout\nstderr\n"));
 }
 
 TEST_F(DumpstateTest, RunCommandWithOneArg) {
-    EXPECT_EQ(0, RunCommand("", {echoCommand, "one"}));
+    EXPECT_EQ(0, RunCommand("", {echo_command, "one"}));
     EXPECT_THAT(err, IsEmpty());
     EXPECT_THAT(out, StrEq("one\n"));
 }
 
 TEST_F(DumpstateTest, RunCommandWithMultipleArgs) {
-    EXPECT_EQ(0, RunCommand("", {echoCommand, "one", "is", "the", "loniest", "number"}));
+    EXPECT_EQ(0, RunCommand("", {echo_command, "one", "is", "the", "loniest", "number"}));
     EXPECT_THAT(err, IsEmpty());
     EXPECT_THAT(out, StrEq("one is the loniest number\n"));
 }
 
 TEST_F(DumpstateTest, RunCommandDryRun) {
     SetDryRun(true);
-    EXPECT_EQ(0, RunCommand("I AM GROOT", {simpleCommand}));
+    EXPECT_EQ(0, RunCommand("I AM GROOT", {simple_command}));
     // We don't know the exact duration, so we check the prefix and suffix
-    EXPECT_THAT(out, StartsWith("------ I AM GROOT (" + simpleCommand +
+    EXPECT_THAT(out, StartsWith("------ I AM GROOT (" + simple_command +
                                 ") ------\n\t(skipped on dry run)\n------"));
     EXPECT_THAT(out, EndsWith("s was the duration of 'I AM GROOT' ------\n"));
     EXPECT_THAT(err, IsEmpty());
@@ -194,14 +194,14 @@
 
 TEST_F(DumpstateTest, RunCommandDryRunNoTitle) {
     SetDryRun(true);
-    EXPECT_EQ(0, RunCommand("", {simpleCommand}));
+    EXPECT_EQ(0, RunCommand("", {simple_command}));
     EXPECT_THAT(out, IsEmpty());
     EXPECT_THAT(err, IsEmpty());
 }
 
 TEST_F(DumpstateTest, RunCommandDryRunAlways) {
     SetDryRun(true);
-    EXPECT_EQ(0, RunCommand("", {simpleCommand}, CommandOptions::WithTimeout(10).Always().Build()));
+    EXPECT_EQ(0, RunCommand("", {simple_command}, CommandOptions::WithTimeout(10).Always().Build()));
     EXPECT_THAT(out, StrEq("stdout\n"));
     EXPECT_THAT(err, StrEq("stderr\n"));
 }
@@ -213,28 +213,28 @@
 }
 
 TEST_F(DumpstateTest, RunCommandFails) {
-    EXPECT_EQ(42, RunCommand("", {simpleCommand, "--exit", "42"}));
-    EXPECT_THAT(
-        out, StrEq("stdout\n*** command '" + simpleCommand + " --exit 42' failed: exit code 42\n"));
-    EXPECT_THAT(
-        err, StrEq("stderr\n*** command '" + simpleCommand + " --exit 42' failed: exit code 42\n"));
+    EXPECT_EQ(42, RunCommand("", {simple_command, "--exit", "42"}));
+    EXPECT_THAT(out, StrEq("stdout\n*** command '" + simple_command +
+                           " --exit 42' failed: exit code 42\n"));
+    EXPECT_THAT(err, StrEq("stderr\n*** command '" + simple_command +
+                           " --exit 42' failed: exit code 42\n"));
 }
 
 TEST_F(DumpstateTest, RunCommandCrashes) {
-    EXPECT_NE(0, RunCommand("", {simpleCommand, "--crash"}));
+    EXPECT_NE(0, RunCommand("", {simple_command, "--crash"}));
     // We don't know the exit code, so check just the prefix.
     EXPECT_THAT(
-        out, StartsWith("stdout\n*** command '" + simpleCommand + " --crash' failed: exit code"));
+        out, StartsWith("stdout\n*** command '" + simple_command + " --crash' failed: exit code"));
     EXPECT_THAT(
-        err, StartsWith("stderr\n*** command '" + simpleCommand + " --crash' failed: exit code"));
+        err, StartsWith("stderr\n*** command '" + simple_command + " --crash' failed: exit code"));
 }
 
 TEST_F(DumpstateTest, RunCommandTimesout) {
-    EXPECT_EQ(-1, RunCommand("", {simpleCommand, "--sleep", "2"},
+    EXPECT_EQ(-1, RunCommand("", {simple_command, "--sleep", "2"},
                              CommandOptions::WithTimeout(1).Build()));
-    EXPECT_THAT(out, StartsWith("stdout line1\n*** command '" + simpleCommand +
+    EXPECT_THAT(out, StartsWith("stdout line1\n*** command '" + simple_command +
                                 " --sleep 2' timed out after 1"));
-    EXPECT_THAT(err, StartsWith("sleeping for 2s\n*** command '" + simpleCommand +
+    EXPECT_THAT(err, StartsWith("sleeping for 2s\n*** command '" + simple_command +
                                 " --sleep 2' timed out after 1"));
 }
 
@@ -243,7 +243,7 @@
     CaptureStderr();
 
     std::thread t([=]() {
-        EXPECT_EQ(SIGTERM, ds.RunCommand("", {simpleCommand, "--pid", "--sleep", "20"},
+        EXPECT_EQ(SIGTERM, ds.RunCommand("", {simple_command, "--pid", "--sleep", "20"},
                                          CommandOptions::WithTimeout(100).Always().Build()));
     });
 
@@ -270,53 +270,53 @@
     out = GetCapturedStdout();
     err = GetCapturedStderr();
 
-    EXPECT_THAT(out, StrEq("*** command '" + simpleCommand +
+    EXPECT_THAT(out, StrEq("*** command '" + simple_command +
                            " --pid --sleep 20' failed: killed by signal 15\n"));
-    EXPECT_THAT(err, StrEq("*** command '" + simpleCommand +
+    EXPECT_THAT(err, StrEq("*** command '" + simple_command +
                            " --pid --sleep 20' failed: killed by signal 15\n"));
 }
 
 TEST_F(DumpstateTest, RunCommandProgress) {
-    ds.updateProgress_ = true;
+    ds.update_progress_ = true;
     ds.progress_ = 0;
-    ds.weightTotal_ = 30;
+    ds.weight_total_ = 30;
 
-    EXPECT_EQ(0, RunCommand("", {simpleCommand}, CommandOptions::WithTimeout(20).Build()));
-    std::string progressMessage = GetProgressMessage(20, 30);
+    EXPECT_EQ(0, RunCommand("", {simple_command}, CommandOptions::WithTimeout(20).Build()));
+    std::string progress_message = GetProgressMessage(20, 30);
     EXPECT_THAT(out, StrEq("stdout\n"));
-    EXPECT_THAT(err, StrEq("stderr\n" + progressMessage));
+    EXPECT_THAT(err, StrEq("stderr\n" + progress_message));
 
-    EXPECT_EQ(0, RunCommand("", {simpleCommand}, CommandOptions::WithTimeout(10).Build()));
-    progressMessage = GetProgressMessage(30, 30);
+    EXPECT_EQ(0, RunCommand("", {simple_command}, CommandOptions::WithTimeout(10).Build()));
+    progress_message = GetProgressMessage(30, 30);
     EXPECT_THAT(out, StrEq("stdout\n"));
-    EXPECT_THAT(err, StrEq("stderr\n" + progressMessage));
+    EXPECT_THAT(err, StrEq("stderr\n" + progress_message));
 
     // Run a command that will increase maximum timeout.
-    EXPECT_EQ(0, RunCommand("", {simpleCommand}, CommandOptions::WithTimeout(1).Build()));
-    progressMessage = GetProgressMessage(31, 36, 30);  // 20% increase
+    EXPECT_EQ(0, RunCommand("", {simple_command}, CommandOptions::WithTimeout(1).Build()));
+    progress_message = GetProgressMessage(31, 36, 30);  // 20% increase
     EXPECT_THAT(out, StrEq("stdout\n"));
-    EXPECT_THAT(err, StrEq("stderr\n" + progressMessage));
+    EXPECT_THAT(err, StrEq("stderr\n" + progress_message));
 
-    // Make sure command ran while in dryRun is counted.
+    // Make sure command ran while in dry_run is counted.
     SetDryRun(true);
-    EXPECT_EQ(0, RunCommand("", {simpleCommand}, CommandOptions::WithTimeout(4).Build()));
-    progressMessage = GetProgressMessage(35, 36);
+    EXPECT_EQ(0, RunCommand("", {simple_command}, CommandOptions::WithTimeout(4).Build()));
+    progress_message = GetProgressMessage(35, 36);
     EXPECT_THAT(out, IsEmpty());
-    EXPECT_THAT(err, StrEq(progressMessage));
+    EXPECT_THAT(err, StrEq(progress_message));
 }
 
 TEST_F(DumpstateTest, RunCommandDropRoot) {
     // First check root case - only available when running with 'adb root'.
     uid_t uid = getuid();
     if (uid == 0) {
-        EXPECT_EQ(0, RunCommand("", {simpleCommand, "--uid"}));
+        EXPECT_EQ(0, RunCommand("", {simple_command, "--uid"}));
         EXPECT_THAT(out, StrEq("0\nstdout\n"));
         EXPECT_THAT(err, StrEq("stderr\n"));
         return;
     }
     // Then drop root.
 
-    EXPECT_EQ(0, RunCommand("", {simpleCommand, "--uid"},
+    EXPECT_EQ(0, RunCommand("", {simple_command, "--uid"},
                             CommandOptions::WithTimeout(1).DropRoot().Build()));
     EXPECT_THAT(out, StrEq("2000\nstdout\n"));
     EXPECT_THAT(err, StrEq("drop_root_user(): already running as Shell\nstderr\n"));
@@ -330,11 +330,11 @@
 
     DropRoot();
 
-    EXPECT_EQ(0, RunCommand("", {simpleCommand}, CommandOptions::WithTimeout(1).AsRoot().Build()));
+    EXPECT_EQ(0, RunCommand("", {simple_command}, CommandOptions::WithTimeout(1).AsRoot().Build()));
 
     // We don't know the exact path of su, so we just check for the 'root ...' commands
     EXPECT_THAT(out, StartsWith("Skipping"));
-    EXPECT_THAT(out, EndsWith("root " + simpleCommand + "' on user build.\n"));
+    EXPECT_THAT(out, EndsWith("root " + simple_command + "' on user build.\n"));
     EXPECT_THAT(err, IsEmpty());
 }
 
@@ -346,7 +346,7 @@
 
     DropRoot();
 
-    EXPECT_EQ(0, RunCommand("", {simpleCommand, "--uid"},
+    EXPECT_EQ(0, RunCommand("", {simple_command, "--uid"},
                             CommandOptions::WithTimeout(1).AsRoot().Build()));
 
     EXPECT_THAT(out, StrEq("0\nstdout\n"));
@@ -370,55 +370,55 @@
 }
 
 TEST_F(DumpstateTest, DumpFileSingleLine) {
-    EXPECT_EQ(0, DumpFile("", testDataPath + "single-line.txt"));
+    EXPECT_EQ(0, DumpFile("", test_data_path + "single-line.txt"));
     EXPECT_THAT(err, IsEmpty());
     EXPECT_THAT(out, StrEq("I AM LINE1\n"));  // dumpstate adds missing newline
 }
 
 TEST_F(DumpstateTest, DumpFileSingleLineWithNewLine) {
-    EXPECT_EQ(0, DumpFile("", testDataPath + "single-line-with-newline.txt"));
+    EXPECT_EQ(0, DumpFile("", test_data_path + "single-line-with-newline.txt"));
     EXPECT_THAT(err, IsEmpty());
     EXPECT_THAT(out, StrEq("I AM LINE1\n"));
 }
 
 TEST_F(DumpstateTest, DumpFileMultipleLines) {
-    EXPECT_EQ(0, DumpFile("", testDataPath + "multiple-lines.txt"));
+    EXPECT_EQ(0, DumpFile("", test_data_path + "multiple-lines.txt"));
     EXPECT_THAT(err, IsEmpty());
     EXPECT_THAT(out, StrEq("I AM LINE1\nI AM LINE2\nI AM LINE3\n"));
 }
 
 TEST_F(DumpstateTest, DumpFileMultipleLinesWithNewLine) {
-    EXPECT_EQ(0, DumpFile("", testDataPath + "multiple-lines-with-newline.txt"));
+    EXPECT_EQ(0, DumpFile("", test_data_path + "multiple-lines-with-newline.txt"));
     EXPECT_THAT(err, IsEmpty());
     EXPECT_THAT(out, StrEq("I AM LINE1\nI AM LINE2\nI AM LINE3\n"));
 }
 
 TEST_F(DumpstateTest, DumpFileOnDryRunNoTitle) {
     SetDryRun(true);
-    EXPECT_EQ(0, DumpFile("", testDataPath + "single-line.txt"));
+    EXPECT_EQ(0, DumpFile("", test_data_path + "single-line.txt"));
     EXPECT_THAT(err, IsEmpty());
     EXPECT_THAT(out, IsEmpty());
 }
 
 TEST_F(DumpstateTest, DumpFileOnDryRun) {
     SetDryRun(true);
-    EXPECT_EQ(0, DumpFile("Might as well dump. Dump!", testDataPath + "single-line.txt"));
+    EXPECT_EQ(0, DumpFile("Might as well dump. Dump!", test_data_path + "single-line.txt"));
     EXPECT_THAT(err, IsEmpty());
-    EXPECT_THAT(out, StartsWith("------ Might as well dump. Dump! (" + testDataPath +
+    EXPECT_THAT(out, StartsWith("------ Might as well dump. Dump! (" + test_data_path +
                                 "single-line.txt) ------\n\t(skipped on dry run)\n------"));
     EXPECT_THAT(out, EndsWith("s was the duration of 'Might as well dump. Dump!' ------\n"));
     EXPECT_THAT(err, IsEmpty());
 }
 
 TEST_F(DumpstateTest, DumpFileUpdateProgress) {
-    ds.updateProgress_ = true;
+    ds.update_progress_ = true;
     ds.progress_ = 0;
-    ds.weightTotal_ = 30;
+    ds.weight_total_ = 30;
 
-    EXPECT_EQ(0, DumpFile("", testDataPath + "single-line.txt"));
+    EXPECT_EQ(0, DumpFile("", test_data_path + "single-line.txt"));
 
-    std::string progressMessage = GetProgressMessage(5, 30);  // TODO: unhardcode WEIGHT_FILE (5)?
+    std::string progress_message = GetProgressMessage(5, 30);  // TODO: unhardcode WEIGHT_FILE (5)?
 
-    EXPECT_THAT(err, StrEq(progressMessage));
+    EXPECT_THAT(err, StrEq(progress_message));
     EXPECT_THAT(out, StrEq("I AM LINE1\n"));  // dumpstate adds missing newline
 }
diff --git a/cmds/dumpstate/utils.cpp b/cmds/dumpstate/utils.cpp
index fc9c037..31c8697 100644
--- a/cmds/dumpstate/utils.cpp
+++ b/cmds/dumpstate/utils.cpp
@@ -59,9 +59,9 @@
 
 // TODO: temporary variables and functions used during C++ refactoring
 static Dumpstate& ds = Dumpstate::GetInstance();
-static int RunCommand(const std::string& title, const std::vector<std::string>& fullCommand,
+static int RunCommand(const std::string& title, const std::vector<std::string>& full_command,
                       const CommandOptions& options = CommandOptions::DEFAULT) {
-    return ds.RunCommand(title, fullCommand, options);
+    return ds.RunCommand(title, full_command, options);
 }
 static bool IsDryRun() {
     return Dumpstate::GetInstance().IsDryRun();
@@ -95,82 +95,83 @@
 CommandOptions CommandOptions::AS_ROOT_10 = CommandOptions::WithTimeout(10).AsRoot().Build();
 CommandOptions CommandOptions::AS_ROOT_20 = CommandOptions::WithTimeout(20).AsRoot().Build();
 
-CommandOptions::CommandOptionsBuilder::CommandOptionsBuilder(long timeout) : values_(timeout) {
+CommandOptions::CommandOptionsBuilder::CommandOptionsBuilder(long timeout) : values(timeout) {
 }
 
 CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::Always() {
-    values_.always_ = true;
+    values.always_ = true;
     return *this;
 }
 
 CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::AsRoot() {
-    values_.rootMode_ = SU_ROOT;
+    values.root_mode_ = SU_ROOT;
     return *this;
 }
 
 CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::DropRoot() {
-    values_.rootMode_ = DROP_ROOT;
+    values.root_mode_ = DROP_ROOT;
     return *this;
 }
 
 CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::RedirectStderr() {
-    values_.stdoutMode_ = REDIRECT_TO_STDERR;
+    values.stdout_mode_ = REDIRECT_TO_STDERR;
     return *this;
 }
 
 CommandOptions::CommandOptionsBuilder& CommandOptions::CommandOptionsBuilder::Log(
     const std::string& message) {
-    values_.loggingMessage_ = message;
+    values.logging_message_ = message;
     return *this;
 }
 
 CommandOptions CommandOptions::CommandOptionsBuilder::Build() {
-    return CommandOptions(values_);
+    return CommandOptions(values);
 }
 
 CommandOptions::CommandOptionsValues::CommandOptionsValues(long timeout)
     : timeout_(timeout),
       always_(false),
-      rootMode_(DONT_DROP_ROOT),
-      stdoutMode_(NORMAL_STDOUT),
-      loggingMessage_("") {
+      root_mode_(DONT_DROP_ROOT),
+      stdout_mode_(NORMAL_STDOUT),
+      logging_message_("") {
 }
 
-CommandOptions::CommandOptions(const CommandOptionsValues& values) : values_(values) {
+CommandOptions::CommandOptions(const CommandOptionsValues& values) : values(values) {
 }
 
 long CommandOptions::Timeout() const {
-    return values_.timeout_;
+    return values.timeout_;
 }
 
 bool CommandOptions::Always() const {
-    return values_.always_;
+    return values.always_;
 }
 
 RootMode CommandOptions::RootMode() const {
-    return values_.rootMode_;
+    return values.root_mode_;
 }
 
 StdoutMode CommandOptions::StdoutMode() const {
-    return values_.stdoutMode_;
+    return values.stdout_mode_;
 }
 
 std::string CommandOptions::LoggingMessage() const {
-    return values_.loggingMessage_;
+    return values.logging_message_;
 }
 
 CommandOptions::CommandOptionsBuilder CommandOptions::WithTimeout(long timeout) {
     return CommandOptions::CommandOptionsBuilder(timeout);
 }
 
-Dumpstate::Dumpstate(bool dryRun, const std::string& buildType)
-    : now_(time(nullptr)), dryRun_(dryRun), buildType_(buildType) {
+Dumpstate::Dumpstate(const std::string& version, bool dry_run, const std::string& build_type)
+    : version_(version), now_(time(nullptr)), dry_run_(dry_run), build_type_(build_type) {
 }
 
 Dumpstate& Dumpstate::GetInstance() {
-    static Dumpstate sSingleton(android::base::GetBoolProperty("dumpstate.dry_run", false),
+    static Dumpstate singleton_(android::base::GetProperty("dumpstate.version", VERSION_CURRENT),
+                                android::base::GetBoolProperty("dumpstate.dry_run", false),
                                 android::base::GetProperty("ro.build.type", "(unknown)"));
-    return sSingleton;
+    return singleton_;
 }
 
 DurationReporter::DurationReporter(const std::string& title) : DurationReporter(title, stdout) {
@@ -202,15 +203,15 @@
 }
 
 bool Dumpstate::IsDryRun() const {
-    return dryRun_;
+    return dry_run_;
 }
 
 bool Dumpstate::IsUserBuild() const {
-    return "user" == buildType_;
+    return "user" == build_type_;
 }
 
 std::string Dumpstate::GetPath(const std::string& suffix) const {
-    return android::base::StringPrintf("%s/%s-%s%s", bugreportDir_.c_str(), baseName_.c_str(),
+    return android::base::StringPrintf("%s/%s-%s%s", bugreport_dir_.c_str(), base_name_.c_str(),
                                        name_.c_str(), suffix.c_str());
 }
 
@@ -546,11 +547,6 @@
         }
         printf(") ------\n");
     }
-    if (IsDryRun()) {
-        UpdateProgress(WEIGHT_FILE);
-        close(fd);
-        return 0;
-    }
 
     bool newline = false;
     fd_set read_set;
@@ -597,7 +593,7 @@
 }
 
 int Dumpstate::DumpFile(const std::string& title, const std::string& path) {
-    DurationReporter durationReporter(title);
+    DurationReporter duration_reporter(title);
     if (IsDryRun()) {
         if (!title.empty()) {
             printf("------ %s (%s) ------\n", title.c_str(), path.c_str());
@@ -778,41 +774,41 @@
     return true;
 }
 
-int Dumpstate::RunCommand(const std::string& title, const std::vector<std::string>& fullCommand,
+int Dumpstate::RunCommand(const std::string& title, const std::vector<std::string>& full_command,
                           const CommandOptions& options) {
-    if (fullCommand.empty()) {
+    if (full_command.empty()) {
         MYLOGE("No arguments on command '%s'\n", title.c_str());
         return -1;
     }
 
-    int size = fullCommand.size() + 1;  // null terminated
-    int startingIndex = 0;
+    int size = full_command.size() + 1;  // null terminated
+    int starting_index = 0;
     if (options.RootMode() == SU_ROOT) {
-        startingIndex = 2;  // "su" "root"
-        size += startingIndex;
+        starting_index = 2;  // "su" "root"
+        size += starting_index;
     }
 
     std::vector<const char*> args;
     args.resize(size);
 
-    std::string commandString;
+    std::string command_string;
     if (options.RootMode() == SU_ROOT) {
         args[0] = SU_PATH;
-        commandString += SU_PATH;
+        command_string += SU_PATH;
         args[1] = "root";
-        commandString += " root ";
+        command_string += " root ";
     }
-    int i = startingIndex;
-    for (auto arg = fullCommand.begin(); arg != fullCommand.end(); ++arg) {
+    int i = starting_index;
+    for (auto arg = full_command.begin(); arg != full_command.end(); ++arg) {
         args[i++] = arg->c_str();
-        commandString += arg->c_str();
-        if (arg != fullCommand.end() - 1) {
-            commandString += " ";
+        command_string += arg->c_str();
+        if (arg != full_command.end() - 1) {
+            command_string += " ";
         }
     }
     args[i] = nullptr;
     const char* path = args[0];
-    const char* command = commandString.c_str();
+    const char* command = command_string.c_str();
 
     if (options.RootMode() == SU_ROOT && ds.IsUserBuild()) {
         printf("Skipping '%s' on user build.\n", command);
@@ -824,11 +820,11 @@
     }
 
     fflush(stdout);
-    DurationReporter durationReporter(title);
+    DurationReporter duration_reporter(title);
 
-    const std::string& loggingMessage = options.LoggingMessage();
-    if (!loggingMessage.empty()) {
-        MYLOGI(loggingMessage.c_str(), commandString.c_str());
+    const std::string& logging_message = options.LoggingMessage();
+    if (!logging_message.empty()) {
+        MYLOGI(logging_message.c_str(), command_string.c_str());
     }
 
     if (IsDryRun() && !options.Always()) {
@@ -945,11 +941,11 @@
     return status;
 }
 
-void Dumpstate::RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsysArgs,
+void Dumpstate::RunDumpsys(const std::string& title, const std::vector<std::string>& dumpsys_args,
                            const CommandOptions& options, long dumpsysTimeout) {
     long timeout = dumpsysTimeout > 0 ? dumpsysTimeout : options.Timeout();
     std::vector<std::string> dumpsys = {"/system/bin/dumpsys", "-t", std::to_string(timeout)};
-    dumpsys.insert(dumpsys.end(), dumpsysArgs.begin(), dumpsysArgs.end());
+    dumpsys.insert(dumpsys.end(), dumpsys_args.begin(), dumpsys_args.end());
     RunCommand(title, dumpsys, options);
 }
 
@@ -1315,7 +1311,7 @@
 
 // TODO: make this function thread safe if sections are generated in parallel.
 void Dumpstate::UpdateProgress(int delta) {
-    if (!updateProgress_) return;
+    if (!update_progress_) return;
 
     progress_ += delta;
 
@@ -1323,12 +1319,12 @@
     char value[PROPERTY_VALUE_MAX];
 
     // adjusts max on the fly
-    if (progress_ > weightTotal_) {
-        int newTotal = weightTotal_ * 1.2;
-        MYLOGD("Adjusting total weight from %d to %d\n", weightTotal_, newTotal);
-        weightTotal_ = newTotal;
+    if (progress_ > weight_total_) {
+        int new_total = weight_total_ * 1.2;
+        MYLOGD("Adjusting total weight from %d to %d\n", weight_total_, new_total);
+        weight_total_ = new_total;
         snprintf(key, sizeof(key), "dumpstate.%d.max", getpid());
-        snprintf(value, sizeof(value), "%d", weightTotal_);
+        snprintf(value, sizeof(value), "%d", weight_total_);
         int status = property_set(key, value);
         if (status != 0) {
             MYLOGE("Could not update max weight by setting system property %s to %s: %d\n",
@@ -1341,16 +1337,16 @@
 
     if (progress_ % 100 == 0) {
         // We don't want to spam logcat, so only log multiples of 100.
-        MYLOGD("Setting progress (%s): %s/%d\n", key, value, weightTotal_);
+        MYLOGD("Setting progress (%s): %s/%d\n", key, value, weight_total_);
     } else {
         // stderr is ignored on normal invocations, but useful when calling /system/bin/dumpstate
         // directly for debuggging.
-        fprintf(stderr, "Setting progress (%s): %s/%d\n", key, value, weightTotal_);
+        fprintf(stderr, "Setting progress (%s): %s/%d\n", key, value, weight_total_);
     }
 
-    if (controlSocketFd_ >= 0) {
-        dprintf(controlSocketFd_, "PROGRESS:%d/%d\n", progress_, weightTotal_);
-        fsync(controlSocketFd_);
+    if (control_socket_fd_ >= 0) {
+        dprintf(control_socket_fd_, "PROGRESS:%d/%d\n", progress_, weight_total_);
+        fsync(control_socket_fd_);
     }
 
     int status = property_set(key, value);
@@ -1361,14 +1357,14 @@
 }
 
 void Dumpstate::TakeScreenshot(const std::string& path) {
-    const std::string& realPath = path.empty() ? screenshotPath_ : path;
+    const std::string& real_path = path.empty() ? screenshot_path_ : path;
     int status =
-        RunCommand("", {"/system/bin/screencap", "-p", realPath},
+        RunCommand("", {"/system/bin/screencap", "-p", real_path},
                    CommandOptions::WithTimeout(10).Always().DropRoot().RedirectStderr().Build());
     if (status == 0) {
-        MYLOGD("Screenshot saved on %s\n", realPath.c_str());
+        MYLOGD("Screenshot saved on %s\n", real_path.c_str());
     } else {
-        MYLOGE("Failed to take screenshot on %s\n", realPath.c_str());
+        MYLOGE("Failed to take screenshot on %s\n", real_path.c_str());
     }
 }