Add logging to remote commands

components/policy/core/common/remote_commands/remote_commands_service.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 "components/policy/core/common/remote_commands/remote_commands_service.h"
 
 #include <algorithm>
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
-#include "base/logging.h"
+#include "base/chromeos/logging.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "components/policy/core/common/cloud/cloud_policy_client.h"
 #include "components/policy/core/common/remote_commands/remote_commands_factory.h"
 
 namespace policy {
 
 namespace em = enterprise_management;
 
 RemoteCommandsService::RemoteCommandsService(
@@ skipping 48 matching lines @@
 }
 
 void RemoteCommandsService::SetClockForTesting(
     std::unique_ptr<base::TickClock> clock) {
   queue_.SetClockForTesting(std::move(clock));
 }
 
 void RemoteCommandsService::EnqueueCommand(
     const enterprise_management::RemoteCommand& command) {
   if (!command.has_type() || !command.has_unique_id()) {
-    LOG(WARNING) << "Invalid remote command from server.";
+    CHROMEOS_SYSLOG(ERROR) << "Invalid remote command from server.";
     return;
   }
 
   // If the command is already fetched, ignore it.
   if (std::find(fetched_command_ids_.begin(), fetched_command_ids_.end(),
                 command.unique_id()) != fetched_command_ids_.end()) {
     return;
   }
 
   fetched_command_ids_.push_back(command.unique_id());
 
   std::unique_ptr<RemoteCommandJob> job =
       factory_->BuildJobForType(command.type());
 
   if (!job || !job->Init(queue_.GetNowTicks(), command)) {
+    CHROMEOS_SYSLOG(ERROR) << "Initialization of remote command failed.";
     em::RemoteCommandResult ignored_result;
     ignored_result.set_result(
         em::RemoteCommandResult_ResultType_RESULT_IGNORED);
     ignored_result.set_unique_id(command.unique_id());
     unsent_results_.push_back(ignored_result);
     return;
   }
 
   queue_.AddJob(std::move(job));
 }
@@ skipping 24 matching lines @@
         command->GetResultPayload();
     if (result_payload)
       result.set_payload(*result_payload);
   } else if (command->status() == RemoteCommandJob::EXPIRED ||
              command->status() == RemoteCommandJob::INVALID) {
     result.set_result(em::RemoteCommandResult_ResultType_RESULT_IGNORED);
   } else {
     NOTREACHED();
   }
 
+  CHROMEOS_SYSLOG(WARNING) << "Remote command " << command->unique_id()
+                           << " finished with result " << result.result();
+
   unsent_results_.push_back(result);
 
   FetchRemoteCommands();
 }
 
 void RemoteCommandsService::OnRemoteCommandsFetched(
     DeviceManagementStatus status,
     const std::vector<enterprise_management::RemoteCommand>& commands) {
   DCHECK(command_fetch_in_progress_);
   command_fetch_in_progress_ = false;
 
   // TODO(binjin): Add retrying on errors. See http://crbug.com/466572.
   if (status == DM_STATUS_SUCCESS) {
     for (const auto& command : commands)
       EnqueueCommand(command);
   }
 
   // Start another fetch request job immediately if there are unsent command
   // results or enqueued fetch requests.
   if (!unsent_results_.empty() || has_enqueued_fetch_request_)
     FetchRemoteCommands();
 }
 
 }  // namespace policy