Disable screenshot uploading if there has been user input.

chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job_unittest.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 <map>
 #include <vector>
 
 #include "ash/test/ash_test_base.h"
 #include "base/json/json_writer.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job.h"
+#include "chrome/browser/chromeos/policy/status_uploader.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "policy/proto/device_management_backend.pb.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace policy {
 
 namespace em = enterprise_management;
@@ skipping 144 matching lines @@
                                                 base::Bind(callback, test_png));
 }
 
 scoped_ptr<UploadJob> MockScreenshotDelegate::CreateUploadJob(
     const GURL& upload_url,
     UploadJob::Delegate* delegate) {
   return make_scoped_ptr(
       new MockUploadJob(upload_url, delegate, upload_job_error_code_.Pass()));
 }
 
+// Mock StatusUploader to test behavior when screenshots are/are not allowed.
+class MockStatusUploader : public StatusUploader {
+ public:
+  explicit MockStatusUploader(bool screenshot_allowed)
+      : screenshot_allowed_(screenshot_allowed) {}
+
+  bool IsSessionDataUploadAllowed() override { return screenshot_allowed_; }
+
+ private:
+  bool screenshot_allowed_;
+};
+
 }  // namespace
 
 class DeviceCommandScreenshotTest : public ash::test::AshTestBase {
  public:
   void VerifyResults(RemoteCommandJob* job,
                      RemoteCommandJob::Status expected_status,
                      std::string expected_payload);
 
  protected:
   DeviceCommandScreenshotTest();
@@ skipping 57 matching lines @@
   EXPECT_EQ(expected_status, job->status());
   if (job->status() == RemoteCommandJob::SUCCEEDED) {
     scoped_ptr<std::string> payload = job->GetResultPayload();
     EXPECT_TRUE(payload);
     EXPECT_EQ(expected_payload, *payload);
   }
   run_loop_.Quit();
 }
 
 TEST_F(DeviceCommandScreenshotTest, Success) {
+  MockStatusUploader uploader(true);
   scoped_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
-      make_scoped_ptr(new MockScreenshotDelegate(nullptr))));
+      make_scoped_ptr(new MockScreenshotDelegate(nullptr)), &uploader));
   InitializeScreenshotJob(job.get(), kUniqueID, test_start_time_,
                           kMockUploadUrl);
   bool success = job->Run(
       base::TimeTicks::Now(),
       base::Bind(
           &DeviceCommandScreenshotTest::VerifyResults, base::Unretained(this),
           base::Unretained(job.get()), RemoteCommandJob::SUCCEEDED,
           CreatePayloadFromResultCode(DeviceCommandScreenshotJob::SUCCESS)));
   EXPECT_TRUE(success);
   run_loop_.Run();
 }
 
+TEST_F(DeviceCommandScreenshotTest, FailureUserInput) {
+  MockStatusUploader uploader(false);
+  scoped_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
+      make_scoped_ptr(new MockScreenshotDelegate(nullptr)), &uploader));
+  InitializeScreenshotJob(job.get(), kUniqueID, test_start_time_,
+                          kMockUploadUrl);
+  bool success =
+      job->Run(base::TimeTicks::Now(),
+               base::Bind(&DeviceCommandScreenshotTest::VerifyResults,
+                          base::Unretained(this), base::Unretained(job.get()),
+                          RemoteCommandJob::FAILED,
+                          CreatePayloadFromResultCode(
+                              DeviceCommandScreenshotJob::FAILURE_USER_INPUT)));
+  EXPECT_TRUE(success);
+  run_loop_.Run();
+}
+
 TEST_F(DeviceCommandScreenshotTest, Failure) {
+  MockStatusUploader uploader(true);
   using ErrorCode = UploadJob::ErrorCode;
   scoped_ptr<ErrorCode> error_code(
       new ErrorCode(UploadJob::AUTHENTICATION_ERROR));
   scoped_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
-      make_scoped_ptr(new MockScreenshotDelegate(error_code.Pass()))));
+      make_scoped_ptr(new MockScreenshotDelegate(error_code.Pass())),
+      &uploader));
   InitializeScreenshotJob(job.get(), kUniqueID, test_start_time_,
                           kMockUploadUrl);
   bool success = job->Run(
       base::TimeTicks::Now(),
       base::Bind(&DeviceCommandScreenshotTest::VerifyResults,
                  base::Unretained(this), base::Unretained(job.get()),
                  RemoteCommandJob::FAILED,
                  CreatePayloadFromResultCode(
                      DeviceCommandScreenshotJob::FAILURE_AUTHENTICATION)));
   EXPECT_TRUE(success);
   run_loop_.Run();
 }
 
 }  // namespace policy