Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(45)

Side by Side Diff: chrome/browser/safe_browsing/chrome_cleaner/reporter_runner_browsertest_win.cc

Issue 2890023005: Chrome Cleaner UI: reporter no longer uses mojo. (Closed)
Patch Set: Move main run function to inside the ChromeCleanerRunner class. Created 3 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
OLDNEW
1 // Copyright 2015 The Chromium Authors. All rights reserved. 1 // Copyright 2015 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be 2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file. 3 // found in the LICENSE file.
4 4
5 #include "chrome/browser/safe_browsing/chrome_cleaner/reporter_runner_win.h" 5 #include "chrome/browser/safe_browsing/chrome_cleaner/reporter_runner_win.h"
6 6
7 #include <initializer_list> 7 #include <initializer_list>
8 #include <set> 8 #include <set>
9 #include <tuple>
10 #include <utility> 9 #include <utility>
11 #include <vector> 10 #include <vector>
12 11
13 #include "base/bind.h" 12 #include "base/bind.h"
14 #include "base/bind_helpers.h" 13 #include "base/bind_helpers.h"
15 #include "base/callback.h" 14 #include "base/callback.h"
16 #include "base/callback_helpers.h" 15 #include "base/callback_helpers.h"
17 #include "base/files/file_path.h" 16 #include "base/files/file_path.h"
18 #include "base/macros.h" 17 #include "base/macros.h"
19 #include "base/memory/ref_counted.h" 18 #include "base/memory/ref_counted.h"
20 #include "base/message_loop/message_loop.h" 19 #include "base/message_loop/message_loop.h"
21 #include "base/run_loop.h" 20 #include "base/run_loop.h"
22 #include "base/strings/string_number_conversions.h"
23 #include "base/test/multiprocess_test.h"
24 #include "base/test/scoped_feature_list.h" 21 #include "base/test/scoped_feature_list.h"
25 #include "base/test/test_mock_time_task_runner.h" 22 #include "base/test/test_mock_time_task_runner.h"
26 #include "base/threading/sequenced_task_runner_handle.h" 23 #include "base/threading/sequenced_task_runner_handle.h"
27 #include "base/threading/thread_task_runner_handle.h" 24 #include "base/threading/thread_task_runner_handle.h"
28 #include "base/time/time.h" 25 #include "base/time/time.h"
29 #include "base/version.h" 26 #include "base/version.h"
30 #include "chrome/browser/browser_process.h" 27 #include "chrome/browser/browser_process.h"
31 #include "chrome/browser/lifetime/keep_alive_types.h" 28 #include "chrome/browser/lifetime/keep_alive_types.h"
32 #include "chrome/browser/lifetime/scoped_keep_alive.h" 29 #include "chrome/browser/lifetime/scoped_keep_alive.h"
33 #include "chrome/browser/profiles/profile.h" 30 #include "chrome/browser/profiles/profile.h"
34 #include "chrome/browser/safe_browsing/chrome_cleaner/srt_chrome_prompt_impl.h"
35 #include "chrome/browser/safe_browsing/chrome_cleaner/srt_client_info_win.h" 31 #include "chrome/browser/safe_browsing/chrome_cleaner/srt_client_info_win.h"
32 #include "chrome/browser/safe_browsing/chrome_cleaner/srt_field_trial_win.h"
36 #include "chrome/browser/ui/browser.h" 33 #include "chrome/browser/ui/browser.h"
37 #include "chrome/browser/ui/browser_finder.h" 34 #include "chrome/browser/ui/browser_finder.h"
38 #include "chrome/browser/ui/test/test_browser_dialog.h" 35 #include "chrome/browser/ui/test/test_browser_dialog.h"
39 #include "chrome/common/pref_names.h" 36 #include "chrome/common/pref_names.h"
40 #include "chrome/test/base/in_process_browser_test.h" 37 #include "chrome/test/base/in_process_browser_test.h"
41 #include "components/chrome_cleaner/public/constants/constants.h" 38 #include "components/chrome_cleaner/public/constants/constants.h"
42 #include "components/component_updater/pref_names.h" 39 #include "components/component_updater/pref_names.h"
43 #include "components/prefs/pref_service.h" 40 #include "components/prefs/pref_service.h"
44 #include "components/safe_browsing/common/safe_browsing_prefs.h" 41 #include "components/safe_browsing/common/safe_browsing_prefs.h"
45 #include "mojo/edk/embedder/embedder.h"
46 #include "mojo/edk/embedder/incoming_broker_client_invitation.h"
47 #include "mojo/edk/embedder/scoped_ipc_support.h"
48 #include "mojo/edk/system/core.h"
49 #include "testing/multiprocess_func_list.h"
50 42
51 namespace safe_browsing { 43 namespace safe_browsing {
52 44
53 namespace { 45 namespace {
54 46
55 using chrome_cleaner::mojom::ElevationStatus; 47 // Parameter for this test:
56 using chrome_cleaner::mojom::PromptAcceptance; 48 // - bool in_browser_cleaner_ui: indicates if InBrowserCleanerUI feature
57 49 // is enabled;
58 // Special switches passed by the parent process (test case) to the reporter 50 //
59 // child process to indicate the behavior that should be mocked. 51 // We expect that the reporter's logic should remain unchanged even when the
60 constexpr char kExitCodeToReturnSwitch[] = "exit-code-to-return"; 52 // InBrowserCleanerUI feature is enabled with one exception: the reporter is
61 constexpr char kReportUwSFoundSwitch[] = "report-uws-found"; 53 // not run daily because with the new feature enabled there is no concept of
62 constexpr char kReportElevationRequiredSwitch[] = "report-elevation-required"; 54 // a pending prompt. See the RunDaily and InBrowserUINoRunDaily tests.
63 constexpr char kExpectedPromptAcceptanceSwitch[] = "expected-prompt-acceptance"; 55 class ReporterRunnerTest : public InProcessBrowserTest,
64 constexpr char kExpectedReporterFailureSwitch[] = "expected-reporter-crash"; 56 public SwReporterTestingDelegate,
65 57 public ::testing::WithParamInterface<bool> {
66 // The exit code to be returned in case of failure in the child process.
67 // This should never be passed as the expected exit code to be reported by
68 // tests.
69 constexpr int kFailureExitCode = -1;
70
71 // Pass the |prompt_acceptance| to the mock child process in command line
72 // switch kExpectedPromptAcceptanceSwitch.
73 void AddPromptAcceptanceToCommandLine(PromptAcceptance prompt_acceptance,
74 base::CommandLine* command_line) {
75 command_line->AppendSwitchASCII(
76 kExpectedPromptAcceptanceSwitch,
77 base::IntToString(static_cast<int>(prompt_acceptance)));
78 }
79
80 // Parses and returns the prompt acceptance value passed by the parent process
81 // in command line switch kExpectedPromptAcceptanceSwitch. Returns
82 // PromptAcceptance::UNSPECIFIED if the switch doesn't exist or can't be
83 // parsed to a valid PromptAcceptance enumerator.
84 PromptAcceptance PromptAcceptanceFromCommandLine(
85 const base::CommandLine& command_line) {
86 const std::string& prompt_acceptance_str =
87 command_line.GetSwitchValueASCII(kExpectedPromptAcceptanceSwitch);
88 int val = -1;
89 if (base::StringToInt(prompt_acceptance_str, &val)) {
90 PromptAcceptance prompt_acceptance = static_cast<PromptAcceptance>(val);
91 if (chrome_cleaner::mojom::IsKnownEnumValue(prompt_acceptance))
92 return prompt_acceptance;
93 }
94 return PromptAcceptance::UNSPECIFIED;
95 }
96
97 // Pointer to ChromePromptPtr object to be used by the child process. The
98 // object must be created, deleted, and accessed on the IPC thread only.
99 chrome_cleaner::mojom::ChromePromptPtr* g_chrome_prompt_ptr = nullptr;
100
101 // Potential failures in the reporter process that should be handled by the
102 // parent process.
103 enum class MockedReporterFailure {
104 kNone = 0,
105 // Crashes at specific moments in the reporter when connected to the IPC.
106 kCrashOnStartup = 1,
107 kCrashAfterConnectedToParentProcess = 2,
108 kCrashWhileWaitingForResponse = 3,
109 kCrashAfterReceivedResponse = 4,
110 // Once an IPC message is sent by the reporter, the parent process will
111 // report a bad message that will lead to an invocation of OnConnectionError.
112 kBadMessageReported = 5,
113 };
114
115 void AddExpectedCrashToCommandLine(MockedReporterFailure reporter_failure,
116 base::CommandLine* command_line) {
117 command_line->AppendSwitchASCII(
118 kExpectedReporterFailureSwitch,
119 base::IntToString(static_cast<int>(reporter_failure)));
120 }
121
122 void CrashIf(MockedReporterFailure reporter_failure) {
123 base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
124 const std::string& expected_str =
125 command_line->GetSwitchValueASCII(kExpectedReporterFailureSwitch);
126 int val = -1;
127 if (base::StringToInt(expected_str, &val) &&
128 static_cast<MockedReporterFailure>(val) == reporter_failure) {
129 exit(kFailureExitCode);
130 }
131 }
132
133 // The callback function to be passed to ChromePrompt::PromptUser to check if
134 // the prompt accepted returned by the parent process is equal to
135 // |expected_prompt_acceptance|. Will set |expected_value_received| with the
136 // comparison result, so that the main thread can report failure. Will invoke
137 // |done| callback when done.
138 void PromptUserCallback(const base::Closure& done,
139 PromptAcceptance expected_prompt_acceptance,
140 bool* expected_value_received,
141 PromptAcceptance prompt_acceptance) {
142 *expected_value_received = prompt_acceptance == expected_prompt_acceptance;
143 // It's safe to delete the ChromePromptPtr object here, since it will not be
144 // used anymore by the child process.
145 delete g_chrome_prompt_ptr;
146 g_chrome_prompt_ptr = nullptr;
147 CrashIf(MockedReporterFailure::kCrashAfterReceivedResponse);
148 done.Run();
149 }
150
151 // Mocks the sending of scan results from the child process to the parent
152 // process. Obtains the behavior to be mocked from special switches in
153 // |command_line|. Sets |expected_value_received| as true if the parent
154 // process replies with the expected prompt acceptance value.
155 void SendScanResults(chrome_cleaner::mojom::ChromePromptPtrInfo prompt_ptr_info,
156 const base::CommandLine& command_line,
157 const base::Closure& done,
158 bool* expected_value_received) {
159 constexpr int kDefaultUwSId = 10;
160 constexpr char kDefaultUwSName[] = "RemovedUwS";
161
162 // This pointer will be deleted by PromptUserCallback.
163 g_chrome_prompt_ptr = new chrome_cleaner::mojom::ChromePromptPtr();
164 g_chrome_prompt_ptr->Bind(std::move(prompt_ptr_info));
165
166 std::vector<chrome_cleaner::mojom::UwSPtr> removable_uws_found;
167 if (command_line.HasSwitch(kReportUwSFoundSwitch)) {
168 chrome_cleaner::mojom::UwSPtr uws = chrome_cleaner::mojom::UwS::New();
169 uws->id = kDefaultUwSId;
170 uws->name = kDefaultUwSName;
171 uws->observed_behaviours = chrome_cleaner::mojom::ObservedBehaviours::New();
172 removable_uws_found.push_back(std::move(uws));
173 }
174 const ElevationStatus elevation_status =
175 command_line.HasSwitch(kReportElevationRequiredSwitch)
176 ? ElevationStatus::REQUIRED
177 : ElevationStatus::NOT_REQUIRED;
178 const PromptAcceptance expected_prompt_acceptance =
179 PromptAcceptanceFromCommandLine(command_line);
180
181 // This task is posted to the IPC thread so that it will happen after the
182 // request is sent to the parent process and before the response gets
183 // handled on the IPC thread.
184 base::SequencedTaskRunnerHandle::Get()->PostTask(
185 FROM_HERE,
186 base::Bind(&CrashIf,
187 MockedReporterFailure::kCrashWhileWaitingForResponse));
188
189 (*g_chrome_prompt_ptr)
190 ->PromptUser(
191 std::move(removable_uws_found), elevation_status,
192 base::Bind(&PromptUserCallback, done, expected_prompt_acceptance,
193 expected_value_received));
194 }
195
196 // Connects to the parent process and sends mocked scan results. Returns true
197 // if connection was successful and the prompt acceptance results sent by the
198 // parent process are the same as expected.
199 bool ConnectAndSendDataToParentProcess(
200 const std::string& chrome_mojo_pipe_token,
201 const base::CommandLine& command_line) {
202 DCHECK(!chrome_mojo_pipe_token.empty());
203
204 mojo::edk::Init();
205 base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
206 base::Thread io_thread("IPCThread");
207 if (!io_thread.StartWithOptions(options))
208 return false;
209 mojo::edk::ScopedIPCSupport ipc_support(
210 io_thread.task_runner(),
211 mojo::edk::ScopedIPCSupport::ShutdownPolicy::CLEAN);
212
213 auto invitation =
214 mojo::edk::IncomingBrokerClientInvitation::AcceptFromCommandLine(
215 mojo::edk::TransportProtocol::kLegacy);
216 chrome_cleaner::mojom::ChromePromptPtrInfo prompt_ptr_info(
217 invitation->ExtractMessagePipe(chrome_mojo_pipe_token), 0);
218
219 CrashIf(MockedReporterFailure::kCrashAfterConnectedToParentProcess);
220
221 base::MessageLoop message_loop;
222 base::RunLoop run_loop;
223 // After the response from the parent process is received, this will post a
224 // task to unblock the child process's main thread.
225 auto done = base::Bind(
226 [](scoped_refptr<base::SequencedTaskRunner> main_runner,
227 base::Closure quit_closure) {
228 main_runner->PostTask(FROM_HERE, std::move(quit_closure));
229 },
230 base::SequencedTaskRunnerHandle::Get(),
231 base::Passed(run_loop.QuitClosure()));
232
233 bool expected_value_received = false;
234 io_thread.task_runner()->PostTask(
235 FROM_HERE, base::BindOnce(&SendScanResults, std::move(prompt_ptr_info),
236 command_line, done, &expected_value_received));
237
238 run_loop.Run();
239
240 return expected_value_received;
241 }
242
243 // Mocks a Software Reporter process that returns an exit code specified by
244 // command line switch kExitCodeToReturnSwitch. If a Mojo IPC is available,
245 // this will also connect to the parent process and send mocked scan results
246 // to the parent process using data passed as command line switches.
247 MULTIPROCESS_TEST_MAIN(MockSwReporterProcess) {
248 base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
249 CrashIf(MockedReporterFailure::kCrashOnStartup);
250 const std::string& str =
251 command_line->GetSwitchValueASCII(kExitCodeToReturnSwitch);
252 const std::string& chrome_mojo_pipe_token = command_line->GetSwitchValueASCII(
253 chrome_cleaner::kChromeMojoPipeTokenSwitch);
254 int exit_code_to_report = kFailureExitCode;
255 bool success = base::StringToInt(str, &exit_code_to_report) &&
256 (chrome_mojo_pipe_token.empty() ||
257 ConnectAndSendDataToParentProcess(chrome_mojo_pipe_token,
258 *command_line));
259 return success ? exit_code_to_report : kFailureExitCode;
260 }
261
262 // Decorates a ChromePromptImpl object to simulate failures indentified by the
263 // parent process and keeps track of errors handled. By default, delegates all
264 // actions to the decorated object.
265 class ReportBadMessageChromePromptImpl : public ChromePromptImpl {
266 public:
267 ReportBadMessageChromePromptImpl(
268 chrome_cleaner::mojom::ChromePromptRequest request,
269 bool bad_message_expected,
270 base::Closure on_connection_closed)
271 : ChromePromptImpl(std::move(request), std::move(on_connection_closed)),
272 bad_message_expected_(bad_message_expected) {}
273 ~ReportBadMessageChromePromptImpl() override = default;
274
275 void PromptUser(
276 std::vector<chrome_cleaner::mojom::UwSPtr> removable_uws_found,
277 chrome_cleaner::mojom::ElevationStatus elevation_status,
278 chrome_cleaner::mojom::ChromePrompt::PromptUserCallback callback)
279 override {
280 if (bad_message_expected_)
281 mojo::ReportBadMessage("bad message");
282
283 ChromePromptImpl::PromptUser(std::move(removable_uws_found),
284 elevation_status, std::move(callback));
285 }
286
287 private:
288 bool bad_message_expected_ = false;
289
290 DISALLOW_COPY_AND_ASSIGN(ReportBadMessageChromePromptImpl);
291 };
292
293 // Parameters for this test:
294 // - bool in_browser_cleaner_ui: indicates if InBrowserCleanerUI experiment
295 // is enabled; if so, the parent and the child processes will communicate
296 // via a Mojo IPC.
297 // - ElevationStatus elevation_status: indicates if the scan results sent by
298 // the child process should consider that elevation will be required for
299 // cleanup.
300 // - MockedReporterFailure expected_reporter_failure: indicates errors that
301 // should be simulated in the reporter process.
302 class ReporterRunnerTest
303 : public InProcessBrowserTest,
304 public SwReporterTestingDelegate,
305 public ::testing::WithParamInterface<
306 std::tuple<bool, ElevationStatus, MockedReporterFailure>> {
307 public: 58 public:
308 ReporterRunnerTest() = default; 59 ReporterRunnerTest() = default;
309 60
310 void SetUpInProcessBrowserTestFixture() override { 61 void SetUpInProcessBrowserTestFixture() override {
311 SetSwReporterTestingDelegate(this); 62 SetSwReporterTestingDelegate(this);
312 63
313 std::tie(in_browser_cleaner_ui_, elevation_status_, 64 in_browser_cleaner_ui_ = GetParam();
314 expected_reporter_failure_) = GetParam();
315 // The config should only accept elevation_status_ if InBrowserCleanerUI
316 // feature is enabled.
317 ASSERT_TRUE(elevation_status_ == ElevationStatus::NOT_REQUIRED ||
318 in_browser_cleaner_ui_);
319
320 if (in_browser_cleaner_ui_) 65 if (in_browser_cleaner_ui_)
321 scoped_feature_list_.InitAndEnableFeature(kInBrowserCleanerUIFeature); 66 scoped_feature_list_.InitAndEnableFeature(kInBrowserCleanerUIFeature);
322 else 67 else
323 scoped_feature_list_.InitAndDisableFeature(kInBrowserCleanerUIFeature); 68 scoped_feature_list_.InitAndDisableFeature(kInBrowserCleanerUIFeature);
324 } 69 }
325 70
326 void SetUpOnMainThread() override { 71 void SetUpOnMainThread() override {
327 // During the test, use a task runner with a mock clock. 72 // During the test, use a task runner with a mock clock.
328 saved_task_runner_ = base::ThreadTaskRunnerHandle::Get(); 73 saved_task_runner_ = base::ThreadTaskRunnerHandle::Get();
329 ASSERT_NE(mock_time_task_runner_, saved_task_runner_); 74 ASSERT_NE(mock_time_task_runner_, saved_task_runner_);
(...skipping 17 matching lines...) Expand all
347 92
348 void TearDownInProcessBrowserTestFixture() override { 93 void TearDownInProcessBrowserTestFixture() override {
349 SetSwReporterTestingDelegate(nullptr); 94 SetSwReporterTestingDelegate(nullptr);
350 } 95 }
351 96
352 // Records that the prompt was shown. 97 // Records that the prompt was shown.
353 void TriggerPrompt(Browser* browser, const std::string& version) override { 98 void TriggerPrompt(Browser* browser, const std::string& version) override {
354 prompt_trigger_called_ = true; 99 prompt_trigger_called_ = true;
355 } 100 }
356 101
357 // Spawns and returns a subprocess to mock an execution of the reporter with 102 // Records that the reporter was launched with the parameters given in
358 // the parameters given in |invocation| that will return 103 // |invocation|
359 // |exit_code_to_report_|. If IPC communication needs to be mocked, this will 104 int LaunchReporter(const SwReporterInvocation& invocation) override {
360 // also provide values that define the expected behavior of the child
361 // process.
362 // Records the launch and parameters used for further verification.
363 base::Process LaunchReporter(
364 const SwReporterInvocation& invocation,
365 const base::LaunchOptions& launch_options) override {
366 ++reporter_launch_count_; 105 ++reporter_launch_count_;
367 reporter_launch_parameters_.push_back(invocation); 106 reporter_launch_parameters_.push_back(invocation);
368 if (first_launch_callback_) 107 if (first_launch_callback_)
369 std::move(first_launch_callback_).Run(); 108 std::move(first_launch_callback_).Run();
370 109 return exit_code_to_report_;
371 if (exit_code_to_report_ == kReporterNotLaunchedExitCode)
372 return base::Process(); // IsValid() will return false.
373
374 base::CommandLine command_line(
375 base::GetMultiProcessTestChildBaseCommandLine());
376 command_line.AppendArguments(invocation.command_line,
377 /*include_program=*/false);
378 command_line.AppendSwitchASCII(kExitCodeToReturnSwitch,
379 base::IntToString(exit_code_to_report_));
380
381 if (in_browser_cleaner_ui_) {
382 AddPromptAcceptanceToCommandLine(PromptAcceptance::DENIED, &command_line);
383 if (exit_code_to_report_ == chrome_cleaner::kSwReporterCleanupNeeded) {
384 command_line.AppendSwitch(kReportUwSFoundSwitch);
385 if (elevation_status_ == ElevationStatus::REQUIRED)
386 command_line.AppendSwitch(kReportElevationRequiredSwitch);
387 }
388 }
389
390 if (expected_reporter_failure_ != MockedReporterFailure::kNone)
391 AddExpectedCrashToCommandLine(expected_reporter_failure_, &command_line);
392
393 bad_message_expected_ = expected_reporter_failure_ ==
394 MockedReporterFailure::kBadMessageReported;
395 bad_message_reported_ = false;
396
397 base::SpawnChildResult result = base::SpawnMultiProcessTestChild(
398 "MockSwReporterProcess", command_line, launch_options);
399 return std::move(result.process);
400 } 110 }
401 111
402 // Returns the test's idea of the current time. 112 // Returns the test's idea of the current time.
403 base::Time Now() const override { return mock_time_task_runner_->Now(); } 113 base::Time Now() const override { return mock_time_task_runner_->Now(); }
404 114
405 // Returns a task runner to use when launching the reporter (which is 115 // Returns a task runner to use when launching the reporter (which is
406 // normally a blocking action). 116 // normally a blocking action).
407 base::TaskRunner* BlockingTaskRunner() const override { 117 base::TaskRunner* BlockingTaskRunner() const override {
408 // Use the test's main task runner so that we don't need to pump another 118 // Use the test's main task runner so that we don't need to pump another
409 // message loop. Since the test calls LaunchReporter instead of actually 119 // message loop. Since the test calls LaunchReporter instead of actually
410 // doing a blocking reporter launch, it doesn't matter that the task runner 120 // doing a blocking reporter launch, it doesn't matter that the task runner
411 // doesn't have the MayBlock trait. 121 // doesn't have the MayBlock trait.
412 return mock_time_task_runner_.get(); 122 return mock_time_task_runner_.get();
413 } 123 }
414 124
415 std::unique_ptr<ChromePromptImpl> CreateChromePromptImpl(
416 chrome_cleaner::mojom::ChromePromptRequest request) override {
417 return base::MakeUnique<ReportBadMessageChromePromptImpl>(
418 std::move(request), bad_message_expected_,
419 base::Bind(&ReporterRunnerTest::OnConnectionClosed,
420 base::Unretained(this)));
421 }
422
423 void OnConnectionClosed() override {}
424
425 void OnConnectionError(const std::string& message) override {
426 bad_message_reported_ = true;
427 }
428
429 // Schedules a single reporter to run. 125 // Schedules a single reporter to run.
430 void RunReporter(int exit_code_to_report, 126 void RunReporter(int exit_code_to_report,
431 const base::FilePath& exe_path = base::FilePath()) { 127 const base::FilePath& exe_path = base::FilePath()) {
432 exit_code_to_report_ = exit_code_to_report; 128 exit_code_to_report_ = exit_code_to_report;
433 auto invocation = SwReporterInvocation::FromFilePath(exe_path); 129 auto invocation = SwReporterInvocation::FromFilePath(exe_path);
434 invocation.supported_behaviours = 130 invocation.supported_behaviours =
435 SwReporterInvocation::BEHAVIOUR_LOG_EXIT_CODE_TO_PREFS | 131 SwReporterInvocation::BEHAVIOUR_LOG_EXIT_CODE_TO_PREFS |
436 SwReporterInvocation::BEHAVIOUR_TRIGGER_PROMPT | 132 SwReporterInvocation::BEHAVIOUR_TRIGGER_PROMPT |
437 SwReporterInvocation::BEHAVIOUR_ALLOW_SEND_REPORTER_LOGS; 133 SwReporterInvocation::BEHAVIOUR_ALLOW_SEND_REPORTER_LOGS;
438 134
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after
507 bool expect_prompt) { 203 bool expect_prompt) {
508 EXPECT_TRUE(mock_time_task_runner_->HasPendingTask()); 204 EXPECT_TRUE(mock_time_task_runner_->HasPendingTask());
509 reporter_launch_count_ = 0; 205 reporter_launch_count_ = 0;
510 reporter_launch_parameters_.clear(); 206 reporter_launch_parameters_.clear();
511 prompt_trigger_called_ = false; 207 prompt_trigger_called_ = false;
512 208
513 mock_time_task_runner_->FastForwardBy( 209 mock_time_task_runner_->FastForwardBy(
514 base::TimeDelta::FromDays(days_until_launch)); 210 base::TimeDelta::FromDays(days_until_launch));
515 211
516 EXPECT_EQ(expected_launch_count, reporter_launch_count_); 212 EXPECT_EQ(expected_launch_count, reporter_launch_count_);
517 // Note: a bad message error will not prevent the prompt that is shown to 213 EXPECT_EQ(expect_prompt, prompt_trigger_called_);
518 // the user today. Once we hook the new prompt here, we will need to review
519 // this expectation.
520 EXPECT_EQ(expect_prompt &&
521 (expected_reporter_failure_ == MockedReporterFailure::kNone ||
522 expected_reporter_failure_ ==
523 MockedReporterFailure::kBadMessageReported),
524 prompt_trigger_called_);
525
526 EXPECT_EQ(bad_message_expected_, bad_message_reported_);
527 } 214 }
528 215
529 // Expects that after |days_until_launched| days, the reporter will be 216 // Expects that after |days_until_launched| days, the reporter will be
530 // launched once with each path in |expected_launch_paths|, and TriggerPrompt 217 // launched once with each path in |expected_launch_paths|, and TriggerPrompt
531 // will be called if and only if |expect_prompt| is true. 218 // will be called if and only if |expect_prompt| is true.
532 void ExpectReporterLaunches( 219 void ExpectReporterLaunches(
533 int days_until_launch, 220 int days_until_launch,
534 const std::vector<base::FilePath>& expected_launch_paths, 221 const std::vector<base::FilePath>& expected_launch_paths,
535 bool expect_prompt) { 222 bool expect_prompt) {
536 ExpectReporterLaunches(days_until_launch, expected_launch_paths.size(), 223 ExpectReporterLaunches(days_until_launch, expected_launch_paths.size(),
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after
582 } 269 }
583 270
584 // A task runner with a mock clock. 271 // A task runner with a mock clock.
585 scoped_refptr<base::TestMockTimeTaskRunner> mock_time_task_runner_ = 272 scoped_refptr<base::TestMockTimeTaskRunner> mock_time_task_runner_ =
586 new base::TestMockTimeTaskRunner(); 273 new base::TestMockTimeTaskRunner();
587 274
588 // The task runner that was in use before installing |mock_time_task_runner_|. 275 // The task runner that was in use before installing |mock_time_task_runner_|.
589 scoped_refptr<base::SingleThreadTaskRunner> saved_task_runner_; 276 scoped_refptr<base::SingleThreadTaskRunner> saved_task_runner_;
590 277
591 bool in_browser_cleaner_ui_; 278 bool in_browser_cleaner_ui_;
592 ElevationStatus elevation_status_;
593 MockedReporterFailure expected_reporter_failure_;
594
595 // Indicates if a bad message error should be simulated by the parent
596 // process.
597 bool bad_message_expected_ = false;
598
599 // Set by ReportBadMessageChromePromptImpl if a bad message error is reported.
600 bool bad_message_reported_ = false;
601 279
602 bool prompt_trigger_called_ = false; 280 bool prompt_trigger_called_ = false;
603 int reporter_launch_count_ = 0; 281 int reporter_launch_count_ = 0;
604 std::vector<SwReporterInvocation> reporter_launch_parameters_; 282 std::vector<SwReporterInvocation> reporter_launch_parameters_;
605 int exit_code_to_report_ = kReporterNotLaunchedExitCode; 283 int exit_code_to_report_ = kReporterNotLaunchedExitCode;
606 284
607 // A callback to invoke when the first reporter of a queue is launched. This 285 // A callback to invoke when the first reporter of a queue is launched. This
608 // can be used to perform actions in the middle of a queue of reporters which 286 // can be used to perform actions in the middle of a queue of reporters which
609 // all launch on the same mock clock tick. 287 // all launch on the same mock clock tick.
610 base::OnceClosure first_launch_callback_; 288 base::OnceClosure first_launch_callback_;
(...skipping 349 matching lines...) Expand 10 before | Expand all | Expand 10 after
960 // Logs should also be sent for the next run, even though LastTimeSentReport 638 // Logs should also be sent for the next run, even though LastTimeSentReport
961 // is now recent, because the run is part of the same set of invocations. 639 // is now recent, because the run is part of the same set of invocations.
962 { 640 {
963 SCOPED_TRACE("second launch"); 641 SCOPED_TRACE("second launch");
964 ExpectLoggingSwitches(reporter_launch_parameters_[1], true); 642 ExpectLoggingSwitches(reporter_launch_parameters_[1], true);
965 ExpectLastReportSentInTheLastHour(); 643 ExpectLastReportSentInTheLastHour();
966 } 644 }
967 ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns); 645 ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
968 } 646 }
969 647
970 INSTANTIATE_TEST_CASE_P( 648 INSTANTIATE_TEST_CASE_P(WithInBrowserCleanerUIParam,
971 NoInBrowserCleanerUI, 649 ReporterRunnerTest,
972 ReporterRunnerTest, 650 testing::Bool());
973 testing::Combine(testing::Values(false),
974 testing::Values(ElevationStatus::NOT_REQUIRED),
975 testing::Values(MockedReporterFailure::kNone,
976 MockedReporterFailure::kCrashOnStartup)));
977
978 INSTANTIATE_TEST_CASE_P(
979 InBrowserCleanerUI,
980 ReporterRunnerTest,
981 testing::Combine(
982 testing::Values(true),
983 testing::Values(ElevationStatus::NOT_REQUIRED,
984 ElevationStatus::REQUIRED),
985 testing::Values(
986 MockedReporterFailure::kNone,
987 MockedReporterFailure::kCrashOnStartup,
988 MockedReporterFailure::kCrashAfterConnectedToParentProcess,
989 MockedReporterFailure::kCrashWhileWaitingForResponse,
990 MockedReporterFailure::kCrashAfterReceivedResponse,
991 MockedReporterFailure::kBadMessageReported)));
992 651
993 // This provide tests which allows explicit invocation of the SRT Prompt 652 // This provide tests which allows explicit invocation of the SRT Prompt
994 // useful for checking dialog layout or any other interactive functionality 653 // useful for checking dialog layout or any other interactive functionality
995 // tests. See docs/testing/test_browser_dialog.md for description of the 654 // tests. See docs/testing/test_browser_dialog.md for description of the
996 // testing framework. 655 // testing framework.
997 IN_PROC_BROWSER_TEST_F(ReporterRunnerPromptTest, InvokeDialog_SRTErrorNoFile) { 656 IN_PROC_BROWSER_TEST_F(ReporterRunnerPromptTest, InvokeDialog_SRTErrorNoFile) {
998 RunDialog(); 657 RunDialog();
999 } 658 }
1000 659
1001 IN_PROC_BROWSER_TEST_F(ReporterRunnerPromptTest, InvokeDialog_SRTErrorFile) { 660 IN_PROC_BROWSER_TEST_F(ReporterRunnerPromptTest, InvokeDialog_SRTErrorFile) {
1002 RunDialog(); 661 RunDialog();
1003 } 662 }
1004 663
1005 } // namespace safe_browsing 664 } // namespace safe_browsing
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698