adb_install: Stop passing RecoveryUI as a parameter.

It's already a global declared in common.h which is included by
adb_install.cpp.

Remove '#include "minadbd/fuse_adb_provider.h"' that's not needed by
adb_install.cpp (minadbd takes care of that).

Test: mmma bootable/recovery
Change-Id: I6d08b7abc706b4b05de2ef46a57ced2204ad297e

adb_install.cpp

@@ -14,27 +14,26 @@
  * limitations under the License.
  */
 
-#include <unistd.h>
+#include "adb_install.h"
-#include <dirent.h>
+
 #include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
 #include <stdlib.h>
 #include <string.h>
+#include <sys/stat.h>
 #include <sys/types.h>
 #include <sys/wait.h>
-#include <sys/stat.h>
+#include <unistd.h>
-#include <signal.h>
-#include <fcntl.h>
-
-#include "ui.h"
-#include "install.h"
-#include "common.h"
-#include "adb_install.h"
-#include "minadbd/fuse_adb_provider.h"
-#include "fuse_sideload.h"
 
 #include <android-base/properties.h>
 
-static void set_usb_driver(RecoveryUI* ui, bool enabled) {
+#include "common.h"
+#include "fuse_sideload.h"
+#include "install.h"
+#include "ui.h"
+
+static void set_usb_driver(bool enabled) {
   int fd = open("/sys/class/android_usb/android0/enable", O_WRONLY);
   if (fd < 0) {
     ui->Print("failed to open driver control: %s\n", strerror(errno));
@@ -48,46 +47,44 @@ static void set_usb_driver(RecoveryUI* ui, bool enabled) {
   }
 }
 
-static void stop_adbd(RecoveryUI* ui) {
+static void stop_adbd() {
   ui->Print("Stopping adbd...\n");
   android::base::SetProperty("ctl.stop", "adbd");
-    set_usb_driver(ui, false);
+  set_usb_driver(false);
 }
 
-static void maybe_restart_adbd(RecoveryUI* ui) {
+static void maybe_restart_adbd() {
   if (is_ro_debuggable()) {
     ui->Print("Restarting adbd...\n");
-        set_usb_driver(ui, true);
+    set_usb_driver(true);
     android::base::SetProperty("ctl.start", "adbd");
   }
 }
 
-// How long (in seconds) we wait for the host to start sending us a
+int apply_from_adb(bool* wipe_cache, const char* install_file) {
-// package, before timing out.
-#define ADB_INSTALL_TIMEOUT 300
-
-int apply_from_adb(RecoveryUI* ui, bool* wipe_cache, const char* install_file) {
   modified_flash = true;
 
-    stop_adbd(ui);
+  stop_adbd();
-    set_usb_driver(ui, true);
+  set_usb_driver(true);
 
-    ui->Print("\n\nNow send the package you want to apply\n"
+  ui->Print(
+      "\n\nNow send the package you want to apply\n"
       "to the device with \"adb sideload <filename>\"...\n");
 
   pid_t child;
   if ((child = fork()) == 0) {
-        execl("/sbin/recovery", "recovery", "--adbd", NULL);
+    execl("/sbin/recovery", "recovery", "--adbd", nullptr);
     _exit(EXIT_FAILURE);
   }
 
-    // FUSE_SIDELOAD_HOST_PATHNAME will start to exist once the host
+  // How long (in seconds) we wait for the host to start sending us a package, before timing out.
-    // connects and starts serving a package.  Poll for its
+  static constexpr int ADB_INSTALL_TIMEOUT = 300;
-    // appearance.  (Note that inotify doesn't work with FUSE.)
+
+  // FUSE_SIDELOAD_HOST_PATHNAME will start to exist once the host connects and starts serving a
+  // package. Poll for its appearance. (Note that inotify doesn't work with FUSE.)
   int result = INSTALL_ERROR;
   int status;
   bool waited = false;
-    struct stat st;
   for (int i = 0; i < ADB_INSTALL_TIMEOUT; ++i) {
     if (waitpid(child, &status, WNOHANG) != 0) {
       result = INSTALL_ERROR;
@@ -95,6 +92,7 @@ int apply_from_adb(RecoveryUI* ui, bool* wipe_cache, const char* install_file) {
       break;
     }
 
+    struct stat st;
     if (stat(FUSE_SIDELOAD_HOST_PATHNAME, &st) != 0) {
       if (errno == ENOENT && i < ADB_INSTALL_TIMEOUT - 1) {
         sleep(1);
@@ -111,14 +109,13 @@ int apply_from_adb(RecoveryUI* ui, bool* wipe_cache, const char* install_file) {
   }
 
   if (!waited) {
-        // Calling stat() on this magic filename signals the minadbd
+    // Calling stat() on this magic filename signals the minadbd subprocess to shut down.
-        // subprocess to shut down.
+    struct stat st;
     stat(FUSE_SIDELOAD_HOST_EXIT_PATHNAME, &st);
 
-        // TODO(dougz): there should be a way to cancel waiting for a
+    // TODO: there should be a way to cancel waiting for a package (by pushing some button combo on
-        // package (by pushing some button combo on the device).  For now
+    // the device). For now you just have to 'adb sideload' a file that's not a valid package, like
-        // you just have to 'adb sideload' a file that's not a valid
+    // "/dev/null".
-        // package, like "/dev/null".
     waitpid(child, &status, 0);
   }
 
@@ -130,8 +127,8 @@ int apply_from_adb(RecoveryUI* ui, bool* wipe_cache, const char* install_file) {
     }
   }
 
-    set_usb_driver(ui, false);
+  set_usb_driver(false);
-    maybe_restart_adbd(ui);
+  maybe_restart_adbd();
 
   return result;
 }

adb_install.h

@@ -17,8 +17,6 @@
 #ifndef _ADB_INSTALL_H
 #define _ADB_INSTALL_H
 
-class RecoveryUI;
+int apply_from_adb(bool* wipe_cache, const char* install_file);
-
-int apply_from_adb(RecoveryUI* h, bool* wipe_cache, const char* install_file);
 
 #endif

recovery.cpp

@@ -1155,7 +1155,7 @@ static Device::BuiltinAction prompt_and_wait(Device* device, int status) {
         {
           bool adb = (chosen_action == Device::APPLY_ADB_SIDELOAD);
           if (adb) {
-            status = apply_from_adb(ui, &should_wipe_cache, TEMPORARY_INSTALL_FILE);
+            status = apply_from_adb(&should_wipe_cache, TEMPORARY_INSTALL_FILE);
           } else {
             status = apply_from_sdcard(device, &should_wipe_cache);
           }
@@ -1584,7 +1584,7 @@ int main(int argc, char **argv) {
         if (!sideload_auto_reboot) {
             ui->ShowText(true);
         }
-        status = apply_from_adb(ui, &should_wipe_cache, TEMPORARY_INSTALL_FILE);
+        status = apply_from_adb(&should_wipe_cache, TEMPORARY_INSTALL_FILE);
         if (status == INSTALL_SUCCESS && should_wipe_cache) {
             if (!wipe_cache(false, device)) {
                 status = INSTALL_ERROR;