diagnostics/cros_healthd/routines/subproc_routine.cc - mirrors/cros/chromiumos/platform2 - Git at Google

 // Copyright 2019 The Chromium OS Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "diagnostics/cros_healthd/routines/subproc_routine.h"

 #include <algorithm>
 #include <utility>
 #include <vector>

 #include <base/logging.h>
 #include <base/strings/string_util.h>
 #include <base/process/process_handle.h>

 #include "diagnostics/cros_healthd/routines/diag_process_adapter_impl.h"

 namespace diagnostics {
 namespace mojo_ipc = ::chromeos::cros_healthd::mojom;

 constexpr char kSubprocRoutineCancelledMessage[] = "The routine was cancelled.";
 constexpr char kSubprocRoutineErrorMessage[] =
     "The routine crashed or was killed.";
 constexpr char kSubprocRoutineFailedMessage[] = "Routine failed.";
 constexpr char kSubprocRoutineFailedToLaunchProcessMessage[] =
     "Could not launch the process.";
 constexpr char kSubprocRoutineFailedToStopMessage[] =
     "Failed to stop the routine.";
 constexpr char kSubprocRoutineProcessCancellingMessage[] =
     "Cancelled routine. Waiting for cleanup...";
 constexpr char kSubprocRoutineProcessRunningMessage[] =
     "Routine is still running.";
 constexpr char kSubprocRoutineReadyMessage[] = "Routine is ready.";
 constexpr char kSubprocRoutineSucceededMessage[] = "Routine passed.";

 constexpr uint32_t kSubprocRoutineFakeProgressPercentUnknown = 33;

 mojo_ipc::DiagnosticRoutineStatusEnum
 GetDiagnosticRoutineStatusFromSubprocRoutineStatus(
     SubprocRoutine::SubprocStatus subproc_status) {
   switch (subproc_status) {
     case SubprocRoutine::kSubprocStatusReady:
       return mojo_ipc::DiagnosticRoutineStatusEnum::kReady;
     case SubprocRoutine::kSubprocStatusLaunchFailed:
       return mojo_ipc::DiagnosticRoutineStatusEnum::kFailedToStart;
     case SubprocRoutine::kSubprocStatusRunning:
       return mojo_ipc::DiagnosticRoutineStatusEnum::kRunning;
     case SubprocRoutine::kSubprocStatusCancelling:
       return mojo_ipc::DiagnosticRoutineStatusEnum::kCancelling;
     case SubprocRoutine::kSubprocStatusCompleteSuccess:
       return mojo_ipc::DiagnosticRoutineStatusEnum::kPassed;
     case SubprocRoutine::kSubprocStatusCompleteFailure:
       return mojo_ipc::DiagnosticRoutineStatusEnum::kFailed;
     case SubprocRoutine::kSubprocStatusError:
       return mojo_ipc::DiagnosticRoutineStatusEnum::kError;
     case SubprocRoutine::kSubprocStatusCancelled:
       return mojo_ipc::DiagnosticRoutineStatusEnum::kCancelled;
   }
 }

 std::string GetStatusMessageFromSubprocRoutineStatus(
     SubprocRoutine::SubprocStatus subproc_status) {
   switch (subproc_status) {
     case SubprocRoutine::kSubprocStatusReady:
       return kSubprocRoutineReadyMessage;
     case SubprocRoutine::kSubprocStatusLaunchFailed:
       return kSubprocRoutineFailedToLaunchProcessMessage;
     case SubprocRoutine::kSubprocStatusRunning:
       return kSubprocRoutineProcessRunningMessage;
     case SubprocRoutine::kSubprocStatusCancelling:
       return kSubprocRoutineProcessCancellingMessage;
     case SubprocRoutine::kSubprocStatusCompleteSuccess:
       return kSubprocRoutineSucceededMessage;
     case SubprocRoutine::kSubprocStatusCompleteFailure:
       return kSubprocRoutineFailedMessage;
     case SubprocRoutine::kSubprocStatusError:
       return kSubprocRoutineErrorMessage;
     case SubprocRoutine::kSubprocStatusCancelled:
       return kSubprocRoutineCancelledMessage;
   }
 }

 SubprocRoutine::SubprocRoutine(const base::CommandLine& command_line,
                                uint32_t predicted_duration_in_seconds)
     : SubprocRoutine(std::make_unique<DiagProcessAdapterImpl>(),
                      std::make_unique<base::DefaultTickClock>(),
                      std::list<base::CommandLine>{command_line},
                      predicted_duration_in_seconds) {}

 SubprocRoutine::SubprocRoutine(
     const std::list<base::CommandLine>& command_lines,
     uint32_t total_predicted_duration_in_seconds)
     : SubprocRoutine(std::make_unique<DiagProcessAdapterImpl>(),
                      std::make_unique<base::DefaultTickClock>(),
                      command_lines,
                      total_predicted_duration_in_seconds) {}

 SubprocRoutine::SubprocRoutine(
     std::unique_ptr<DiagProcessAdapter> process_adapter,
     std::unique_ptr<base::TickClock> tick_clock,
     const std::list<base::CommandLine>& command_lines,
     uint32_t predicted_duration_in_seconds)
     : subproc_status_(kSubprocStatusReady),
       process_adapter_(std::move(process_adapter)),
       tick_clock_(std::move(tick_clock)),
       command_lines_(std::move(command_lines)),
       predicted_duration_in_seconds_(predicted_duration_in_seconds) {}

 SubprocRoutine::~SubprocRoutine() {
   // If the routine is still running, make sure to stop it so we aren't left
   // with a zombie process.
   KillProcess(true /*from_dtor*/);
   if (!post_stop_callback_.is_null())
     std::move(post_stop_callback_).Run();
 }

 void SubprocRoutine::Start() {
   DCHECK_EQ(handle_, base::kNullProcessHandle);

   bool pre_start_callback_result = true;
   if (!pre_start_callback_.is_null())
     pre_start_callback_result = std::move(pre_start_callback_).Run();

   if (!pre_start_callback_result) {
     subproc_status_ = kSubprocStatusLaunchFailed;
     LOG(ERROR) << kSubprocRoutineFailedToLaunchProcessMessage;
     return;
   }
   StartProcess();
 }

 void SubprocRoutine::Resume() {
   // Resume functionality is intended to be used by interactive routines.
   // Subprocess routines are non-interactive.
   LOG(ERROR) << "SubprocRoutine::Resume : subprocess diagnostic routines "
                 "cannot be resumed";
 }

 void SubprocRoutine::Cancel() {
   KillProcess(false /*from_dtor*/);
 }

 void SubprocRoutine::PopulateStatusUpdate(mojo_ipc::RoutineUpdate* response,
                                           bool include_output) {
   // Because the subproc_routine routine is non-interactive, we will never
   // include a user message.
   CheckProcessStatus();

   mojo_ipc::NonInteractiveRoutineUpdate update;
   update.status =
       GetDiagnosticRoutineStatusFromSubprocRoutineStatus(subproc_status_);
   update.status_message =
       GetStatusMessageFromSubprocRoutineStatus(subproc_status_);

   response->routine_update_union->set_noninteractive_update(update.Clone());
   response->progress_percent = CalculateProgressPercent();
 }

 mojo_ipc::DiagnosticRoutineStatusEnum SubprocRoutine::GetStatus() {
   CheckProcessStatus();
   return GetDiagnosticRoutineStatusFromSubprocRoutineStatus(subproc_status_);
 }

 void SubprocRoutine::RegisterPreStartCallback(
     base::OnceCallback<bool()> callback) {
   DCHECK(pre_start_callback_.is_null());
   pre_start_callback_ = std::move(callback);
 }

 void SubprocRoutine::RegisterPostStopCallback(base::OnceClosure callback) {
   DCHECK(post_stop_callback_.is_null());
   post_stop_callback_ = std::move(callback);
 }

 void SubprocRoutine::StartProcess() {
   DCHECK_EQ(command_lines_.empty(), false);
   DCHECK(subproc_status_ == kSubprocStatusReady ||
          subproc_status_ == kSubprocStatusRunning);
   if (subproc_status_ == kSubprocStatusReady) {
     // Keep track of when we began the routine, in case we need to predict
     // progress.
     start_ticks_ = tick_clock_->NowTicks();
     subproc_status_ = kSubprocStatusRunning;
   }

   // Multiple executables will be run in sequence and one at a time.
   auto command_line = command_lines_.front();
   command_lines_.pop_front();

   VLOG(1) << "Starting command " << base::JoinString(command_line.argv(), " ");

   if (!process_adapter_->StartProcess(command_line.argv(), &handle_)) {
     subproc_status_ = kSubprocStatusLaunchFailed;
     LOG(ERROR) << kSubprocRoutineFailedToLaunchProcessMessage;
   }
 }

 void SubprocRoutine::KillProcess(bool from_dtor) {
   CheckProcessStatus();

   switch (subproc_status_) {
     case kSubprocStatusRunning:
       DCHECK(handle_ != base::kNullProcessHandle);
       if (from_dtor) {
         // We will not be able to keep track of this child process.
         LOG(ERROR) << "Cancelling process " << handle_
                    << " from diagnostics::SubprocRoutine destructor, cannot "
                       "guarantee process will die.";
       }
       subproc_status_ = kSubprocStatusCancelling;
       process_adapter_->KillProcess(handle_);
       break;
     case kSubprocStatusCancelling:
       // The process is already being killed. Do nothing.
       DCHECK_NE(handle_, base::kNullProcessHandle);
       break;
     case kSubprocStatusCancelled:
     case kSubprocStatusCompleteFailure:
     case kSubprocStatusCompleteSuccess:
     case kSubprocStatusError:
     case kSubprocStatusLaunchFailed:
     case kSubprocStatusReady:
       // If the process has already exited, is exiting, or never started,
       // there's no need to kill it.
       DCHECK_EQ(handle_, base::kNullProcessHandle);
       break;
   }
 }

 void SubprocRoutine::CheckActiveProcessStatus() {
   DCHECK_NE(handle_, base::kNullProcessHandle);
   switch (process_adapter_->GetStatus(handle_)) {
     case base::TERMINATION_STATUS_STILL_RUNNING:
       DCHECK(subproc_status_ == kSubprocStatusCancelling ||
              subproc_status_ == kSubprocStatusRunning);
       break;
     case base::TERMINATION_STATUS_NORMAL_TERMINATION:
       // The process is gone.
       handle_ = base::kNullProcessHandle;
       if (subproc_status_ == kSubprocStatusCancelling) {
         subproc_status_ = kSubprocStatusCancelled;
       } else {
         if (command_lines_.size())
           StartProcess();
         else
           subproc_status_ = kSubprocStatusCompleteSuccess;
       }
       break;
     case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
       // The process is gone.
       handle_ = base::kNullProcessHandle;

       subproc_status_ = (subproc_status_ == kSubprocStatusCancelling)
                             ? kSubprocStatusCancelled
                             : kSubprocStatusCompleteFailure;
       break;
     case base::TERMINATION_STATUS_LAUNCH_FAILED:
       // The process never really was.
       handle_ = base::kNullProcessHandle;

       subproc_status_ = kSubprocStatusLaunchFailed;
       break;
     default:
       // The process is mysteriously just missing.
       handle_ = base::kNullProcessHandle;
       subproc_status_ = kSubprocStatusError;
       break;
   }
 }

 void SubprocRoutine::CheckProcessStatus() {
   switch (subproc_status_) {
     case kSubprocStatusCancelled:
     case kSubprocStatusCompleteFailure:
     case kSubprocStatusCompleteSuccess:
     case kSubprocStatusError:
     case kSubprocStatusLaunchFailed:
     case kSubprocStatusReady:
       DCHECK_EQ(handle_, base::kNullProcessHandle);
       break;
     case kSubprocStatusCancelling:
     case kSubprocStatusRunning:
       CheckActiveProcessStatus();
       break;
   }
 }

 uint32_t SubprocRoutine::CalculateProgressPercent() {
   switch (subproc_status_) {
     case kSubprocStatusCompleteSuccess:
     case kSubprocStatusCompleteFailure:
       last_reported_progress_percent_ = 100;
       break;
     case kSubprocStatusRunning:
       if (predicted_duration_in_seconds_ == 0) {
         /* when we don't know the progress, we fake at a low percentage */
         last_reported_progress_percent_ =
             kSubprocRoutineFakeProgressPercentUnknown;
       } else {
         last_reported_progress_percent_ = std::min<uint32_t>(
             100, std::max<uint32_t>(
                      0, static_cast<uint32_t>(
                             100 * (tick_clock_->NowTicks() - start_ticks_) /
                             base::TimeDelta::FromSeconds(
                                 predicted_duration_in_seconds_))));
       }
       break;
     case kSubprocStatusCancelled:
     case kSubprocStatusCancelling:
     case kSubprocStatusError:
     case kSubprocStatusLaunchFailed:
     case kSubprocStatusReady:
       break;
   }
   return last_reported_progress_percent_;
 }

 }  // namespace diagnostics
	// Copyright 2019 The Chromium OS Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "diagnostics/cros_healthd/routines/subproc_routine.h"

	#include <algorithm>
	#include <utility>
	#include <vector>

	#include <base/logging.h>
	#include <base/strings/string_util.h>
	#include <base/process/process_handle.h>

	#include "diagnostics/cros_healthd/routines/diag_process_adapter_impl.h"

	namespace diagnostics {
	namespace mojo_ipc = ::chromeos::cros_healthd::mojom;

	constexpr char kSubprocRoutineCancelledMessage[] = "The routine was cancelled.";
	constexpr char kSubprocRoutineErrorMessage[] =
	"The routine crashed or was killed.";
	constexpr char kSubprocRoutineFailedMessage[] = "Routine failed.";
	constexpr char kSubprocRoutineFailedToLaunchProcessMessage[] =
	"Could not launch the process.";
	constexpr char kSubprocRoutineFailedToStopMessage[] =
	"Failed to stop the routine.";
	constexpr char kSubprocRoutineProcessCancellingMessage[] =
	"Cancelled routine. Waiting for cleanup...";
	constexpr char kSubprocRoutineProcessRunningMessage[] =
	"Routine is still running.";
	constexpr char kSubprocRoutineReadyMessage[] = "Routine is ready.";
	constexpr char kSubprocRoutineSucceededMessage[] = "Routine passed.";

	constexpr uint32_t kSubprocRoutineFakeProgressPercentUnknown = 33;

	mojo_ipc::DiagnosticRoutineStatusEnum
	GetDiagnosticRoutineStatusFromSubprocRoutineStatus(
	SubprocRoutine::SubprocStatus subproc_status) {
	switch (subproc_status) {
	case SubprocRoutine::kSubprocStatusReady:
	return mojo_ipc::DiagnosticRoutineStatusEnum::kReady;
	case SubprocRoutine::kSubprocStatusLaunchFailed:
	return mojo_ipc::DiagnosticRoutineStatusEnum::kFailedToStart;
	case SubprocRoutine::kSubprocStatusRunning:
	return mojo_ipc::DiagnosticRoutineStatusEnum::kRunning;
	case SubprocRoutine::kSubprocStatusCancelling:
	return mojo_ipc::DiagnosticRoutineStatusEnum::kCancelling;
	case SubprocRoutine::kSubprocStatusCompleteSuccess:
	return mojo_ipc::DiagnosticRoutineStatusEnum::kPassed;
	case SubprocRoutine::kSubprocStatusCompleteFailure:
	return mojo_ipc::DiagnosticRoutineStatusEnum::kFailed;
	case SubprocRoutine::kSubprocStatusError:
	return mojo_ipc::DiagnosticRoutineStatusEnum::kError;
	case SubprocRoutine::kSubprocStatusCancelled:
	return mojo_ipc::DiagnosticRoutineStatusEnum::kCancelled;
	}
	}

	std::string GetStatusMessageFromSubprocRoutineStatus(
	SubprocRoutine::SubprocStatus subproc_status) {
	switch (subproc_status) {
	case SubprocRoutine::kSubprocStatusReady:
	return kSubprocRoutineReadyMessage;
	case SubprocRoutine::kSubprocStatusLaunchFailed:
	return kSubprocRoutineFailedToLaunchProcessMessage;
	case SubprocRoutine::kSubprocStatusRunning:
	return kSubprocRoutineProcessRunningMessage;
	case SubprocRoutine::kSubprocStatusCancelling:
	return kSubprocRoutineProcessCancellingMessage;
	case SubprocRoutine::kSubprocStatusCompleteSuccess:
	return kSubprocRoutineSucceededMessage;
	case SubprocRoutine::kSubprocStatusCompleteFailure:
	return kSubprocRoutineFailedMessage;
	case SubprocRoutine::kSubprocStatusError:
	return kSubprocRoutineErrorMessage;
	case SubprocRoutine::kSubprocStatusCancelled:
	return kSubprocRoutineCancelledMessage;
	}
	}

	SubprocRoutine::SubprocRoutine(const base::CommandLine& command_line,
	uint32_t predicted_duration_in_seconds)
	: SubprocRoutine(std::make_unique<DiagProcessAdapterImpl>(),
	std::make_unique<base::DefaultTickClock>(),
	std::list<base::CommandLine>{command_line},
	predicted_duration_in_seconds) {}

	SubprocRoutine::SubprocRoutine(
	const std::list<base::CommandLine>& command_lines,
	uint32_t total_predicted_duration_in_seconds)
	: SubprocRoutine(std::make_unique<DiagProcessAdapterImpl>(),
	std::make_unique<base::DefaultTickClock>(),
	command_lines,
	total_predicted_duration_in_seconds) {}

	SubprocRoutine::SubprocRoutine(
	std::unique_ptr<DiagProcessAdapter> process_adapter,
	std::unique_ptr<base::TickClock> tick_clock,
	const std::list<base::CommandLine>& command_lines,
	uint32_t predicted_duration_in_seconds)
	: subproc_status_(kSubprocStatusReady),
	process_adapter_(std::move(process_adapter)),
	tick_clock_(std::move(tick_clock)),
	command_lines_(std::move(command_lines)),
	predicted_duration_in_seconds_(predicted_duration_in_seconds) {}

	SubprocRoutine::~SubprocRoutine() {
	// If the routine is still running, make sure to stop it so we aren't left
	// with a zombie process.
	KillProcess(true /from_dtor/);
	if (!post_stop_callback_.is_null())
	std::move(post_stop_callback_).Run();
	}

	void SubprocRoutine::Start() {
	DCHECK_EQ(handle_, base::kNullProcessHandle);

	bool pre_start_callback_result = true;
	if (!pre_start_callback_.is_null())
	pre_start_callback_result = std::move(pre_start_callback_).Run();

	if (!pre_start_callback_result) {
	subproc_status_ = kSubprocStatusLaunchFailed;
	LOG(ERROR) << kSubprocRoutineFailedToLaunchProcessMessage;
	return;
	}
	StartProcess();
	}

	void SubprocRoutine::Resume() {
	// Resume functionality is intended to be used by interactive routines.
	// Subprocess routines are non-interactive.
	LOG(ERROR) << "SubprocRoutine::Resume : subprocess diagnostic routines "
	"cannot be resumed";
	}

	void SubprocRoutine::Cancel() {
	KillProcess(false /from_dtor/);
	}

	void SubprocRoutine::PopulateStatusUpdate(mojo_ipc::RoutineUpdate* response,
	bool include_output) {
	// Because the subproc_routine routine is non-interactive, we will never
	// include a user message.
	CheckProcessStatus();

	mojo_ipc::NonInteractiveRoutineUpdate update;
	update.status =
	GetDiagnosticRoutineStatusFromSubprocRoutineStatus(subproc_status_);
	update.status_message =
	GetStatusMessageFromSubprocRoutineStatus(subproc_status_);

	response->routine_update_union->set_noninteractive_update(update.Clone());
	response->progress_percent = CalculateProgressPercent();
	}

	mojo_ipc::DiagnosticRoutineStatusEnum SubprocRoutine::GetStatus() {
	CheckProcessStatus();
	return GetDiagnosticRoutineStatusFromSubprocRoutineStatus(subproc_status_);
	}

	void SubprocRoutine::RegisterPreStartCallback(
	base::OnceCallback<bool()> callback) {
	DCHECK(pre_start_callback_.is_null());
	pre_start_callback_ = std::move(callback);
	}

	void SubprocRoutine::RegisterPostStopCallback(base::OnceClosure callback) {
	DCHECK(post_stop_callback_.is_null());
	post_stop_callback_ = std::move(callback);
	}

	void SubprocRoutine::StartProcess() {
	DCHECK_EQ(command_lines_.empty(), false);
	DCHECK(subproc_status_ == kSubprocStatusReady \|\|
	subproc_status_ == kSubprocStatusRunning);
	if (subproc_status_ == kSubprocStatusReady) {
	// Keep track of when we began the routine, in case we need to predict
	// progress.
	start_ticks_ = tick_clock_->NowTicks();
	subproc_status_ = kSubprocStatusRunning;
	}

	// Multiple executables will be run in sequence and one at a time.
	auto command_line = command_lines_.front();
	command_lines_.pop_front();

	VLOG(1) << "Starting command " << base::JoinString(command_line.argv(), " ");

	if (!process_adapter_->StartProcess(command_line.argv(), &handle_)) {
	subproc_status_ = kSubprocStatusLaunchFailed;
	LOG(ERROR) << kSubprocRoutineFailedToLaunchProcessMessage;
	}
	}

	void SubprocRoutine::KillProcess(bool from_dtor) {
	CheckProcessStatus();

	switch (subproc_status_) {
	case kSubprocStatusRunning:
	DCHECK(handle_ != base::kNullProcessHandle);
	if (from_dtor) {
	// We will not be able to keep track of this child process.
	LOG(ERROR) << "Cancelling process " << handle_
	<< " from diagnostics::SubprocRoutine destructor, cannot "
	"guarantee process will die.";
	}
	subproc_status_ = kSubprocStatusCancelling;
	process_adapter_->KillProcess(handle_);
	break;
	case kSubprocStatusCancelling:
	// The process is already being killed. Do nothing.
	DCHECK_NE(handle_, base::kNullProcessHandle);
	break;
	case kSubprocStatusCancelled:
	case kSubprocStatusCompleteFailure:
	case kSubprocStatusCompleteSuccess:
	case kSubprocStatusError:
	case kSubprocStatusLaunchFailed:
	case kSubprocStatusReady:
	// If the process has already exited, is exiting, or never started,
	// there's no need to kill it.
	DCHECK_EQ(handle_, base::kNullProcessHandle);
	break;
	}
	}

	void SubprocRoutine::CheckActiveProcessStatus() {
	DCHECK_NE(handle_, base::kNullProcessHandle);
	switch (process_adapter_->GetStatus(handle_)) {
	case base::TERMINATION_STATUS_STILL_RUNNING:
	DCHECK(subproc_status_ == kSubprocStatusCancelling \|\|
	subproc_status_ == kSubprocStatusRunning);
	break;
	case base::TERMINATION_STATUS_NORMAL_TERMINATION:
	// The process is gone.
	handle_ = base::kNullProcessHandle;
	if (subproc_status_ == kSubprocStatusCancelling) {
	subproc_status_ = kSubprocStatusCancelled;
	} else {
	if (command_lines_.size())
	StartProcess();
	else
	subproc_status_ = kSubprocStatusCompleteSuccess;
	}
	break;
	case base::TERMINATION_STATUS_ABNORMAL_TERMINATION:
	// The process is gone.
	handle_ = base::kNullProcessHandle;

	subproc_status_ = (subproc_status_ == kSubprocStatusCancelling)
	? kSubprocStatusCancelled
	: kSubprocStatusCompleteFailure;
	break;
	case base::TERMINATION_STATUS_LAUNCH_FAILED:
	// The process never really was.
	handle_ = base::kNullProcessHandle;

	subproc_status_ = kSubprocStatusLaunchFailed;
	break;
	default:
	// The process is mysteriously just missing.
	handle_ = base::kNullProcessHandle;
	subproc_status_ = kSubprocStatusError;
	break;
	}
	}

	void SubprocRoutine::CheckProcessStatus() {
	switch (subproc_status_) {
	case kSubprocStatusCancelled:
	case kSubprocStatusCompleteFailure:
	case kSubprocStatusCompleteSuccess:
	case kSubprocStatusError:
	case kSubprocStatusLaunchFailed:
	case kSubprocStatusReady:
	DCHECK_EQ(handle_, base::kNullProcessHandle);
	break;
	case kSubprocStatusCancelling:
	case kSubprocStatusRunning:
	CheckActiveProcessStatus();
	break;
	}
	}

	uint32_t SubprocRoutine::CalculateProgressPercent() {
	switch (subproc_status_) {
	case kSubprocStatusCompleteSuccess:
	case kSubprocStatusCompleteFailure:
	last_reported_progress_percent_ = 100;
	break;
	case kSubprocStatusRunning:
	if (predicted_duration_in_seconds_ == 0) {
	/* when we don't know the progress, we fake at a low percentage */
	last_reported_progress_percent_ =
	kSubprocRoutineFakeProgressPercentUnknown;
	} else {
	last_reported_progress_percent_ = std::min<uint32_t>(
	100, std::max<uint32_t>(
	0, static_cast<uint32_t>(
	100 * (tick_clock_->NowTicks() - start_ticks_) /
	base::TimeDelta::FromSeconds(
	predicted_duration_in_seconds_))));
	}
	break;
	case kSubprocStatusCancelled:
	case kSubprocStatusCancelling:
	case kSubprocStatusError:
	case kSubprocStatusLaunchFailed:
	case kSubprocStatusReady:
	break;
	}
	return last_reported_progress_percent_;
	}

	} // namespace diagnostics