Disable screenshot uploading if there has been user input.

chrome/browser/chromeos/policy/remote_commands/device_command_screenshot_job.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/chromeos/policy/remote_commands/device_command_screenshot_job.h"
 
 #include <fstream>
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
+#include "chrome/browser/chromeos/policy/status_uploader.h"
 #include "chrome/browser/chromeos/policy/upload_job_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/http/http_request_headers.h"
 #include "policy/proto/device_management_backend.pb.h"
 
 namespace policy {
 
 namespace {
 
 // Determines the time, measured from the time of issue, after which the command
@@ skipping 55 matching lines @@
   if (result_code != SUCCESS)
     root_dict.Set(kResultFieldName, new base::FundamentalValue(result_code));
   base::JSONWriter::Write(&root_dict, &payload_);
 }
 
 scoped_ptr<std::string> DeviceCommandScreenshotJob::Payload::Serialize() {
   return make_scoped_ptr(new std::string(payload_));
 }
 
 DeviceCommandScreenshotJob::DeviceCommandScreenshotJob(
-    scoped_ptr<Delegate> screenshot_delegate)
+    scoped_ptr<Delegate> screenshot_delegate,
+    StatusUploader* uploader)
     : num_pending_screenshots_(0),
       screenshot_delegate_(screenshot_delegate.Pass()),
+      status_uploader_(uploader),
       weak_ptr_factory_(this) {
   DCHECK(screenshot_delegate_);
 }
 
 DeviceCommandScreenshotJob::~DeviceCommandScreenshotJob() {
 }
 
 enterprise_management::RemoteCommand_Type DeviceCommandScreenshotJob::GetType()
     const {
   return enterprise_management::RemoteCommand_Type_DEVICE_SCREENSHOT;
@@ skipping 83 matching lines @@
     const CallbackWithResult& failed_callback) {
   succeeded_callback_ = succeeded_callback;
   failed_callback_ = failed_callback;
 
   upload_job_ = screenshot_delegate_->CreateUploadJob(upload_url_, this);
   DCHECK(upload_job_);
 
   aura::Window::Windows root_windows = ash::Shell::GetAllRootWindows();
 
   // Immediately fail if there are no attached screens.
   if (root_windows.size() == 0) {

[Andrew T Wilson (Slow), 2015/05/14 09:20:28]

BTW, should this check for attached screens be done before we create the
upload_job_ above?

[cschuet (SLOW), 2015/05/14 09:46:01]

Yes, that makes total sense. Would you move it up?

[Andrew T Wilson (Slow), 2015/05/15 09:43:51]

Done.

     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(failed_callback_, base::Passed(make_scoped_ptr(new Payload(
                                          FAILURE_SCREENSHOT_ACQUISITION)))));
   }
 
+  if (!status_uploader_ || !status_uploader_->IsSessionDataUploadAllowed()) {
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE,
+        base::Bind(failed_callback_, base::Passed(make_scoped_ptr(
+                                         new Payload(FAILURE_USER_INPUT)))));
+  }
+
   // Post tasks to the sequenced worker pool for taking screenshots on each
   // attached screen.
   num_pending_screenshots_ = root_windows.size();
   for (size_t screen = 0; screen < root_windows.size(); ++screen) {
     aura::Window* root_window = root_windows[screen];
     gfx::Rect rect = root_window->bounds();
     screenshot_delegate_->TakeSnapshot(
         root_window, rect,
         base::Bind(&RunStoreScreenshotOnTaskRunner,
                    base::Bind(&DeviceCommandScreenshotJob::StoreScreenshot,
                               weak_ptr_factory_.GetWeakPtr(), screen),
                    base::ThreadTaskRunnerHandle::Get()));
   }
 }
 
 void DeviceCommandScreenshotJob::TerminateImpl() {
   weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 }  // namespace policy