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"
@@ skipping 119 matching lines @@
           gfx::Size(bmp.width(), bmp.height()),
           static_cast<int>(bmp.rowBytes()), false,
           std::vector<gfx::PNGCodec::Comment>(), &png_bytes->data())) {
     LOG(ERROR) << "Failed to encode image";
   }
   return png_bytes;
 }
 
 class MockScreenshotDelegate : public DeviceCommandScreenshotJob::Delegate {
  public:
-  MockScreenshotDelegate(
-      scoped_ptr<UploadJob::ErrorCode> upload_job_error_code);
+  MockScreenshotDelegate(scoped_ptr<UploadJob::ErrorCode> upload_job_error_code,
+                         bool screenshot_allowed);
   ~MockScreenshotDelegate() override;
 
+  bool IsScreenshotAllowed() override;
   void TakeSnapshot(
       gfx::NativeWindow window,
       const gfx::Rect& source_rect,
       const ui::GrabWindowSnapshotAsyncPNGCallback& callback) override;
   scoped_ptr<UploadJob> CreateUploadJob(const GURL&,
                                         UploadJob::Delegate*) override;
 
  private:
   scoped_ptr<UploadJob::ErrorCode> upload_job_error_code_;
+  bool screenshot_allowed_;
 };
 
 MockScreenshotDelegate::MockScreenshotDelegate(
-    scoped_ptr<UploadJob::ErrorCode> upload_job_error_code)
-    : upload_job_error_code_(upload_job_error_code.Pass()) {
+    scoped_ptr<UploadJob::ErrorCode> upload_job_error_code,
+    bool screenshot_allowed)
+    : upload_job_error_code_(upload_job_error_code.Pass()),
+      screenshot_allowed_(screenshot_allowed) {
 }
 
 MockScreenshotDelegate::~MockScreenshotDelegate() {
 }
 
+bool MockScreenshotDelegate::IsScreenshotAllowed() {
+  return screenshot_allowed_;
+}
+
 void MockScreenshotDelegate::TakeSnapshot(
     gfx::NativeWindow window,
     const gfx::Rect& source_rect,
     const ui::GrabWindowSnapshotAsyncPNGCallback& callback) {
   const int width = source_rect.width();
   const int height = source_rect.height();
   scoped_refptr<base::RefCountedBytes> test_png =
       GenerateTestPNG(width, height);
   base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
                                                 base::Bind(callback, test_png));
@@ skipping 77 matching lines @@
   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) {
   scoped_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
-      make_scoped_ptr(new MockScreenshotDelegate(nullptr))));
+      make_scoped_ptr(new MockScreenshotDelegate(nullptr, true))));
   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) {
+  scoped_ptr<RemoteCommandJob> job(new DeviceCommandScreenshotJob(
+      make_scoped_ptr(new MockScreenshotDelegate(nullptr, false))));
+  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) {
   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(), true))));
   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