Adds error handling support for the SwReporter launcher.

chrome/browser/safe_browsing/srt_fetcher_win.cc

 // Copyright 2015 The Chromium 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 "chrome/browser/safe_browsing/srt_fetcher_win.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 27 matching lines @@
 #include "chrome/browser/safe_browsing/srt_chrome_prompt_impl.h"
 #include "chrome/browser/safe_browsing/srt_client_info_win.h"
 #include "chrome/browser/safe_browsing/srt_global_error_win.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
 #include "chrome/common/pref_names.h"
 #include "components/chrome_cleaner/public/constants/constants.h"
-#include "components/chrome_cleaner/public/interfaces/chrome_prompt.mojom.h"
 #include "components/component_updater/pref_names.h"
 #include "components/data_use_measurement/core/data_use_user_data.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/net/variations_http_headers.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "mojo/edk/embedder/connection_params.h"
 #include "mojo/edk/embedder/pending_process_connection.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/public/cpp/system/message_pipe.h"
@@ skipping 479 matching lines @@
       if (error->GetBubbleView()) {
         show_bubble = false;
         break;
       }
     }
   }
   if (show_bubble)
     global_error->ShowBubbleView(browser);
 }
 
+// Handles the case when the remote end has been closed, by performing the
+// necessary cleanups if the prompt dialog is being shown to the user.
+void OnConnectionClosed() {
+  // Placeholder. This should handle cases when the reporter process is
+  // disconnected (e.g. due to a crash) and the prompt dialog is being shown
+  // to the user.
+}
+
+// Handles the case when a mojo::ReportBadMessage has been explicitly reported.
+void OnConnectionError(const std::string& message) {
+  // Placeholder. This should handle cases when the reporter process sends
+  // a bad message and the prompt dialog is being shown to the user.
+}
+
 // Class responsible for launching the reporter process and waiting for its
 // completion. If feature InBrowserCleanerUI is enabled, this object will also
 // be responsible for starting the ChromePromptImpl object on the IO thread and
 // controlling its lifetime.
 //
 // Expected lifecycle of a SwReporterProcess:
 //  - created on the UI thread before the reporter process launch is posted
 //    (method ScheduleNextInvocation);
 //  - deleted on the UI thread once ReporterDone() finishes (the method is
 //    called after the reporter process exits).
@@ skipping 26 matching lines @@
 
  private:
   friend class base::RefCountedThreadSafe<SwReporterProcess>;
   ~SwReporterProcess() = default;
 
   // Starts a new IPC service implementing the ChromePrompt interface and
   // launches a new reporter process that can connect to the IPC.
   base::Process LaunchConnectedReporterProcess();
 
   // Starts a new instance of ChromePromptImpl to receive requests from the
-  // reporter. Must be run on the IO thread.
+  // reporter and establishes the mojo connection to it.
+  // Must be run on the IO thread.
   void CreateChromePromptImpl(
       chrome_cleaner::mojom::ChromePromptRequest chrome_prompt_request);
 
   // Releases the instance of ChromePromptImpl. Must be run on the IO thread.
   void ReleaseChromePromptImpl();
 
   // Launches a new process with the command line in the invocation and
   // provided launch options. Uses g_testing_delegate_ if not null.
   base::Process LaunchReporterProcess(
       const SwReporterInvocation& invocation,
       const base::LaunchOptions& launch_options);
 
   // The invocation for the current reporter process.
   SwReporterInvocation invocation_;
 
   // Implementation of the ChromePrompt service to be used by the current
   // reporter process. Can only be accessed on the IO thread.
   std::unique_ptr<ChromePromptImpl> chrome_prompt_impl_;
 };
 
 int SwReporterProcess::LaunchAndWaitForExitOnBackgroundThread() {
   base::Process reporter_process =
       base::FeatureList::IsEnabled(kInBrowserCleanerUIFeature)
           ? LaunchConnectedReporterProcess()
           : LaunchReporterProcess(invocation_, base::LaunchOptions());
 
   // This exit code is used to identify that a reporter run didn't happen, so
   // the result should be ignored and a rerun scheduled for the usual delay.
-  int exit_code = kReporterFailureExitCode;
+  int exit_code = kReporterNotLaunchedExitCode;
   UMAHistogramReporter uma(invocation_.suffix);
   if (reporter_process.IsValid()) {
     uma.RecordReporterStep(SW_REPORTER_START_EXECUTION);
     bool success = reporter_process.WaitForExit(&exit_code);
     DCHECK(success);
   } else {
     uma.RecordReporterStep(SW_REPORTER_FAILED_TO_START);
   }
   return exit_code;
 }
@@ skipping 27 matching lines @@
                                                   &handles_to_inherit);
 
   base::LaunchOptions launch_options;
   launch_options.handles_to_inherit = &handles_to_inherit;
   base::Process reporter_process =
       LaunchReporterProcess(invocation_, launch_options);
 
   if (!reporter_process.IsValid())
     return reporter_process;
 
-  pending_process_connection.Connect(
-      reporter_process.Handle(),
-      mojo::edk::ConnectionParams(channel.PassServerHandle()));
-
   chrome_cleaner::mojom::ChromePromptRequest chrome_prompt_request;
   chrome_prompt_request.Bind(std::move(mojo_pipe));
 
   // ChromePromptImpl tasks will need to run on the IO thread. There is no
   // need to synchronize its creation, since the client end will wait for this
   // initialization to be done before sending requests.
   BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)
       ->PostTask(FROM_HERE,
                  base::BindOnce(&SwReporterProcess::CreateChromePromptImpl,
                                 base::RetainedRef(this),
                                 std::move(chrome_prompt_request)));
 
+  mojo::edk::ProcessErrorCallback on_connection_error =
+      g_testing_delegate_
+          ? base::Bind(&SwReporterTestingDelegate::OnConnectionError,
+                       base::Unretained(g_testing_delegate_))
+          : base::Bind(&OnConnectionError);
+  pending_process_connection.Connect(
+      reporter_process.Handle(),
+      mojo::edk::ConnectionParams(channel.PassServerHandle()),
+      on_connection_error);
+
   return reporter_process;
 }
 
 base::Process SwReporterProcess::LaunchReporterProcess(
     const SwReporterInvocation& invocation,
     const base::LaunchOptions& launch_options) {
   return g_testing_delegate_
              ? g_testing_delegate_->LaunchReporter(invocation, launch_options)
              : base::LaunchProcess(invocation.command_line, launch_options);
 }
 
 void SwReporterProcess::CreateChromePromptImpl(
     chrome_cleaner::mojom::ChromePromptRequest chrome_prompt_request) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(base::FeatureList::IsEnabled(kInBrowserCleanerUIFeature));
 
   chrome_prompt_impl_ =
-      base::MakeUnique<ChromePromptImpl>(std::move(chrome_prompt_request));
+      g_testing_delegate_
+          ? g_testing_delegate_->CreateChromePromptImpl(
+                std::move(chrome_prompt_request))
+          : base::MakeUnique<ChromePromptImpl>(std::move(chrome_prompt_request),
+                                               base::Bind(&OnConnectionClosed));
 }
 
 void SwReporterProcess::ReleaseChromePromptImpl() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(base::FeatureList::IsEnabled(kInBrowserCleanerUIFeature));
 
   chrome_prompt_impl_.release();
 }
 
 }  // namespace
@@ skipping 212 matching lines @@
                     scoped_refptr<SwReporterProcess> sw_reporter_process,
                     int exit_code) {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     sw_reporter_process->OnReporterDone();
 
     base::Time now = Now();
     base::TimeDelta reporter_running_time = now - reporter_start_time;
 
     // Don't continue the current queue of reporters if one failed to launch.
-    if (exit_code == kReporterFailureExitCode)
+    if (exit_code == kReporterNotLaunchedExitCode)
       current_invocations_ = SwReporterQueue();
 
     // As soon as we're not running this queue, schedule the next overall queue
     // run after the regular delay. (If there was a failure it's not worth
     // retrying earlier, risking running too often if it always fails, since
     // not many users fail here.)
     if (current_invocations_.empty()) {
       base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&ReporterRunner::TryToRun, base::Unretained(this)),
           base::TimeDelta::FromDays(days_between_reporter_runs_));
     } else {
       ScheduleNextInvocation();
     }
 
     // If the reporter failed to launch, do not process the results. (The exit
     // code itself doesn't need to be logged in this case because
     // SW_REPORTER_FAILED_TO_START is logged in
     // |LaunchAndWaitForExitOnBackgroundThread|.)
-    if (exit_code == kReporterFailureExitCode)
+    if (exit_code == kReporterNotLaunchedExitCode)
       return;
 
     const auto& finished_invocation = sw_reporter_process->invocation();
     UMAHistogramReporter uma(finished_invocation.suffix);
     uma.ReportVersion(version);
     uma.ReportExitCode(exit_code);
     uma.ReportEngineErrorCode();
     uma.ReportFoundUwS();
 
     PrefService* local_state = g_browser_process->local_state();
@@ skipping 253 matching lines @@
   return srt_cleaner_key.Open(HKEY_CURRENT_USER, cleaner_key_path.c_str(),
                               KEY_QUERY_VALUE) == ERROR_SUCCESS &&
          srt_cleaner_key.GetValueCount() > 0;
 }
 
 void SetSwReporterTestingDelegate(SwReporterTestingDelegate* delegate) {
   g_testing_delegate_ = delegate;
 }
 
 }  // namespace safe_browsing