Replace CHROMEOS_SYSLOG logs with SYSLOG logs so remote command related logs will get uploaded to t…

chrome/browser/chromeos/policy/status_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 "chrome/browser/chromeos/policy/status_uploader.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
-#include "base/chromeos/logging.h"
 #include "base/location.h"
 #include "base/sequenced_task_runner.h"
 #include "base/sys_info.h"
+#include "base/syslog_logging.h"
 #include "chrome/browser/chromeos/policy/device_local_account.h"
 #include "chrome/browser/chromeos/policy/device_status_collector.h"
 #include "chromeos/settings/cros_settings_names.h"
 #include "chromeos/settings/cros_settings_provider.h"
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 #include "components/policy/core/common/cloud/device_management_service.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/media_request_state.h"
 #include "content/public/common/media_stream_request.h"
 #include "ui/base/user_activity/user_activity_detector.h"
@@ skipping 78 matching lines @@
           base::Bind(&StatusUploader::RefreshUploadFrequency,
                      weak_factory_.GetWeakPtr()))) {
     return;
   }
 
   // CrosSettings are trusted - update our cached upload_frequency (we cache the
   // value because CrosSettings can become untrusted at arbitrary times and we
   // want to use the last trusted value).
   int frequency;
   if (settings->GetInteger(chromeos::kReportUploadFrequency, &frequency)) {
-    CHROMEOS_SYSLOG(WARNING) << "Changing status upload frequency from "
-                             << upload_frequency_ << " to "
-                             << base::TimeDelta::FromMilliseconds(frequency);
+    SYSLOG(INFO) << "Changing status upload frequency from "
+                 << upload_frequency_ << " to "
+                 << base::TimeDelta::FromMilliseconds(frequency);
     upload_frequency_ = base::TimeDelta::FromMilliseconds(
         std::max(kMinUploadDelayMs, frequency));
   }
 
   // Schedule a new upload with the new frequency - only do this if we've
   // already performed the initial upload, because we want the initial upload
   // to happen in a minute after startup and not get cancelled by settings
   // changes.
   if (!last_upload_.is_null())
     ScheduleNextStatusUpload();
 }
 
 bool StatusUploader::IsSessionDataUploadAllowed() {
   // Check if we're in an auto-launched kiosk session.
   std::unique_ptr<DeviceLocalAccount> account =
       collector_->GetAutoLaunchedKioskSessionInfo();
   if (!account) {
-    CHROMEOS_SYSLOG(WARNING)
-        << "Not a kiosk session, data upload is not allowed.";
+    SYSLOG(WARNING) << "Not a kiosk session, data upload is not allowed.";
     return false;
   }
 
   // Check if there has been any user input.
   base::TimeTicks last_activity_time =
       ui::UserActivityDetector::Get()->last_activity_time();
   std::string last_activity_name =
       ui::UserActivityDetector::Get()->last_activity_name();
   if (!last_activity_time.is_null()) {
-    CHROMEOS_SYSLOG(WARNING)
-        << "User input " << last_activity_name << " detected "
-        << (base::TimeTicks::Now() - last_activity_time) << " ago ("
-        << (base::SysInfo::Uptime() -
-            (base::TimeTicks::Now() - last_activity_time))
-        << " after last boot), data upload is not allowed.";
+    SYSLOG(WARNING) << "User input " << last_activity_name << " detected "
+                    << (base::TimeTicks::Now() - last_activity_time) << " ago ("
+                    << (base::SysInfo::Uptime() -
+                        (base::TimeTicks::Now() - last_activity_time))
+                    << " after last boot), data upload is not allowed.";
     return false;
   }
 
   // Screenshot is allowed as long as we have not captured media.
   if (has_captured_media_) {
-    CHROMEOS_SYSLOG(WARNING)
-        << "Media has been captured, data upload is not allowed.";
+    SYSLOG(WARNING) << "Media has been captured, data upload is not allowed.";
     return false;
   } else {
     return true;
   }
 }
 
 void StatusUploader::OnRequestUpdate(int render_process_id,
                                      int render_frame_id,
                                      content::MediaStreamType stream_type,
                                      const content::MediaRequestState state) {
@@ skipping 12 matching lines @@
   collector_->GetDeviceAndSessionStatusAsync(base::Bind(
       &StatusUploader::OnStatusReceived, weak_factory_.GetWeakPtr()));
 }
 
 void StatusUploader::OnStatusReceived(
     std::unique_ptr<em::DeviceStatusReportRequest> device_status,
     std::unique_ptr<em::SessionStatusReportRequest> session_status) {
   bool have_device_status = device_status != nullptr;
   bool have_session_status = session_status != nullptr;
   if (!have_device_status && !have_session_status) {
-    CHROMEOS_SYSLOG(WARNING)
-        << "Skipping status upload because no data to upload";
+    SYSLOG(INFO) << "Skipping status upload because no data to upload";
     // Don't have any status to upload - just set our timer for next time.
     last_upload_ = base::Time::NowFromSystemTime();
     ScheduleNextStatusUpload();
     return;
   }
 
-  CHROMEOS_SYSLOG(WARNING) << "Starting status upload: have_device_status = "
-                           << have_device_status;
+  SYSLOG(INFO) << "Starting status upload: have_device_status = "
+               << have_device_status;
   client_->UploadDeviceStatus(device_status.get(), session_status.get(),
                               base::Bind(&StatusUploader::OnUploadCompleted,
                                          weak_factory_.GetWeakPtr()));
 }
 
 void StatusUploader::OnUploadCompleted(bool success) {
   // Set the last upload time, regardless of whether the upload was successful
   // or not (we don't change the time of the next upload based on whether this
   // upload succeeded or not - if a status upload fails, we just skip it and
   // wait until it's time to try again.
-  CHROMEOS_SYSLOG_IF(ERROR, !success) << "Error uploading status: "
-                                      << client_->status();
-  CHROMEOS_SYSLOG_IF(WARNING, success) << "Status upload successful";
+  if (success) {
+    SYSLOG(INFO) << "Status upload successful";
+  } else {
+    SYSLOG(ERROR) << "Error uploading status: " << client_->status();
+  }
   last_upload_ = base::Time::NowFromSystemTime();
 
   // If the upload was successful, tell the collector so it can clear its cache
   // of pending items.
   if (success)
     collector_->OnSubmittedSuccessfully();
 
   ScheduleNextStatusUpload();
 }
 
 }  // namespace policy