Add logging to remote commands

chrome/browser/chromeos/policy/system_log_uploader.cc

 // Copyright (c) 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 <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
@@ skipping 83 matching lines @@
 std::unique_ptr<policy::UploadJob> SystemLogDelegate::CreateUploadJob(
     const GURL& upload_url,
     policy::UploadJob::Delegate* delegate) {
   chromeos::DeviceOAuth2TokenService* device_oauth2_token_service =
       chromeos::DeviceOAuth2TokenServiceFactory::Get();
 
   scoped_refptr<net::URLRequestContextGetter> system_request_context =
       g_browser_process->system_request_context();
   std::string robot_account_id =
       device_oauth2_token_service->GetRobotAccountId();
+
+  LOG(WARNING) << "Creating upload job for system log";
   return std::unique_ptr<policy::UploadJob>(new policy::UploadJobImpl(
       upload_url, robot_account_id, device_oauth2_token_service,
       system_request_context, delegate,
       base::WrapUnique(
           new policy::UploadJobImpl::RandomMimeBoundaryGenerator)));
 }
 
 // Returns the system log upload frequency.
 base::TimeDelta GetUploadFrequency() {
   base::TimeDelta upload_frequency(base::TimeDelta::FromMilliseconds(
@@ skipping 65 matching lines @@
 
   // Immediately schedule the next system log upload (last_upload_attempt_ is
   // set to the start of the epoch, so this will trigger an update upload in the
   // immediate future).
   ScheduleNextSystemLogUpload(upload_frequency_);
 }
 
 SystemLogUploader::~SystemLogUploader() {}
 
 void SystemLogUploader::OnSuccess() {
+  LOG(WARNING) << "Upload successful.";
   upload_job_.reset();
   last_upload_attempt_ = base::Time::NowFromSystemTime();
   retry_count_ = 0;
 
   // On successful log upload schedule the next log upload after
   // upload_frequency_ time from now.
   ScheduleNextSystemLogUpload(upload_frequency_);
 }
 
 void SystemLogUploader::OnFailure(UploadJob::ErrorCode error_code) {
   upload_job_.reset();
   last_upload_attempt_ = base::Time::NowFromSystemTime();
 
   //  If we have hit the maximum number of retries, terminate this upload
   //  attempt and schedule the next one using the normal delay. Otherwise, retry
   //  uploading after kErrorUploadDelayMs milliseconds.
   if (retry_count_++ < kMaxNumRetries) {
+    LOG(ERROR) << "Upload failed, retrying later.";

[Andrew T Wilson (Slow), 2016/05/04 14:43:23]

Log the error code.

[Marton Hunyady, 2016/05/09 13:48:15]

Done.

     ScheduleNextSystemLogUpload(
         base::TimeDelta::FromMilliseconds(kErrorUploadDelayMs));
   } else {
     // No more retries.

[Andrew T Wilson (Slow), 2016/05/04 14:43:23]

Log error code (unless it's logged elsewhere)

[Marton Hunyady, 2016/05/09 13:48:15]

Done.

+    LOG(ERROR) << "Upload failed, no more retries.";
     retry_count_ = 0;
     ScheduleNextSystemLogUpload(upload_frequency_);
   }
 }
 
 // static
 std::string SystemLogUploader::RemoveSensitiveData(
     feedback::AnonymizerTool* const anonymizer,
     const std::string& data) {
   return anonymizer->Anonymize(data);
@@ skipping 66 matching lines @@
       base::TimeDelta());
   // Ensure that we never have more than one pending delayed task.
   weak_factory_.InvalidateWeakPtrs();
   task_runner_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&SystemLogUploader::StartLogUpload,
                                            weak_factory_.GetWeakPtr()),
                                 delay);
 }
 
 }  // namespace policy