Add logging to remote commands

chrome/browser/chromeos/policy/upload_job_impl.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 "chrome/browser/chromeos/policy/upload_job_impl.h"
 
 #include <stddef.h>
 #include <set>
 #include <utility>
 
+#include "base/chromeos/logging.h"
 #include "base/location.h"
-#include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/stringprintf.h"
 #include "google_apis/gaia/gaia_constants.h"
 #include "google_apis/gaia/google_service_auth_error.h"
 #include "net/base/mime_util.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_request_status.h"
 
 namespace policy {
 
@@ skipping 150 matching lines @@
 }
 
 void UploadJobImpl::Start() {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Cannot start an upload on a busy or failed instance.
   DCHECK_EQ(IDLE, state_);
   if (state_ != IDLE)
     return;
   DCHECK_EQ(0, retry_);
 
+  CHROMEOS_SYSLOG(WARNING) << "Upload job started";
   RequestAccessToken();
 }
 
 // static
 void UploadJobImpl::SetRetryDelayForTesting(long retry_delay_ms) {
   CHECK_GE(retry_delay_ms, 0);
   g_retry_delay_ms = retry_delay_ms;
 }
 
 void UploadJobImpl::RequestAccessToken() {
@@ skipping 56 matching lines @@
     for (const auto& entry : data_segment->GetHeaderEntries()) {
       post_data_->append(entry.first + ": " + entry.second + "\r\n");
     }
     std::unique_ptr<std::string> data = data_segment->GetData();
     post_data_->append("\r\n" + *data + "\r\n");
   }
   post_data_->append("--" + *mime_boundary_.get() + "--\r\n");
 
   // Issues a warning if our buffer size estimate was too small.
   if (post_data_->size() > size) {
-    LOG(WARNING)
+    CHROMEOS_SYSLOG(WARNING)
         << "Reallocation needed in POST data buffer. Expected maximum size "
         << size << " bytes, actual size " << post_data_->size() << " bytes.";
   }
 
   // Discard the data segments as they are not needed anymore from here on.
   data_segments_.clear();
 
   return true;
 }
 
@@ skipping 11 matching lines @@
   upload_fetcher_->SetUploadData(content_type, *post_data_);
   upload_fetcher_->AddExtraRequestHeader(
       base::StringPrintf(kAuthorizationHeaderFormat, access_token.c_str()));
   upload_fetcher_->Start();
 }
 
 void UploadJobImpl::StartUpload() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!SetUpMultipart()) {
-    LOG(ERROR) << "Multipart message assembly failed.";
+    CHROMEOS_SYSLOG(ERROR) << "Multipart message assembly failed.";
     state_ = ERROR;
     return;
   }
   CreateAndStartURLFetcher(access_token_);
   state_ = UPLOADING;
 }
 
 void UploadJobImpl::OnGetTokenSuccess(
     const OAuth2TokenService::Request* request,
     const std::string& access_token,
     const base::Time& expiration_time) {
   DCHECK_EQ(ACQUIRING_TOKEN, state_);
   DCHECK_EQ(access_token_request_.get(), request);
   access_token_request_.reset();
 
   // Also cache the token locally, so that we can revoke it later if necessary.
   access_token_ = access_token;
   StartUpload();
 }
 
 void UploadJobImpl::OnGetTokenFailure(
     const OAuth2TokenService::Request* request,
     const GoogleServiceAuthError& error) {
   DCHECK_EQ(ACQUIRING_TOKEN, state_);
   DCHECK_EQ(access_token_request_.get(), request);
   access_token_request_.reset();
-  LOG(ERROR) << "Token request failed: " << error.ToString();
+  CHROMEOS_SYSLOG(ERROR) << "Token request failed: " << error.ToString();
   HandleError(AUTHENTICATION_ERROR);
 }
 
 void UploadJobImpl::HandleError(ErrorCode error_code) {
   retry_++;
   upload_fetcher_.reset();
 
-  LOG(ERROR) << "Upload failed, error code: " << error_code;
+  CHROMEOS_SYSLOG(ERROR) << "Upload failed, error code: " << error_code;
 
   if (retry_ >= kMaxAttempts) {
     // Maximum number of attempts reached, failure.
-    LOG(ERROR) << "Maximum number of attempts reached.";
+    CHROMEOS_SYSLOG(ERROR) << "Maximum number of attempts reached.";
     access_token_.clear();
     post_data_.reset();
     state_ = ERROR;
     delegate_->OnFailure(error_code);
   } else {
     if (error_code == AUTHENTICATION_ERROR) {
-      LOG(ERROR) << "Retrying upload with a new token.";
+      CHROMEOS_SYSLOG(ERROR) << "Retrying upload with a new token.";
       // Request new token and retry.
       OAuth2TokenService::ScopeSet scope_set;
       scope_set.insert(GaiaConstants::kDeviceManagementServiceOAuth);
       token_service_->InvalidateAccessToken(account_id_, scope_set,
                                             access_token_);
       access_token_.clear();
       task_runner_->PostDelayedTask(
           FROM_HERE, base::Bind(&UploadJobImpl::RequestAccessToken,
                                 weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(g_retry_delay_ms));
     } else {
       // Retry without a new token.
       state_ = ACQUIRING_TOKEN;
-      LOG(WARNING) << "Retrying upload with the same token.";
+      CHROMEOS_SYSLOG(WARNING) << "Retrying upload with the same token.";
       task_runner_->PostDelayedTask(
           FROM_HERE,
           base::Bind(&UploadJobImpl::StartUpload, weak_factory_.GetWeakPtr()),
           base::TimeDelta::FromMilliseconds(g_retry_delay_ms));
     }
   }
 }
 
 void UploadJobImpl::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK_EQ(upload_fetcher_.get(), source);
   DCHECK_EQ(UPLOADING, state_);
   const net::URLRequestStatus& status = source->GetStatus();
   if (!status.is_success()) {
-    LOG(ERROR) << "URLRequestStatus error " << status.error();
+    CHROMEOS_SYSLOG(ERROR) << "URLRequestStatus error " << status.error();
     HandleError(NETWORK_ERROR);
   } else {
     const int response_code = source->GetResponseCode();
     if (response_code == net::HTTP_OK) {
       // Successful upload
       upload_fetcher_.reset();
       access_token_.clear();
       post_data_.reset();
       state_ = SUCCESS;
       delegate_->OnSuccess();
     } else if (response_code == net::HTTP_UNAUTHORIZED) {
-      LOG(ERROR) << "Unauthorized request.";
+      CHROMEOS_SYSLOG(ERROR) << "Unauthorized request.";
       HandleError(AUTHENTICATION_ERROR);
     } else {
-      LOG(ERROR) << "POST request failed with HTTP status code "
-                 << response_code << ".";
+      CHROMEOS_SYSLOG(ERROR) << "POST request failed with HTTP status code "
+                             << response_code << ".";
       HandleError(SERVER_ERROR);
     }
   }
 }
 
 }  // namespace policy