Match server version of DM API proto.

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>
 
@@ skipping 65 matching lines @@
   return true;
 }
 
 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()) {
+  if (!command.has_type() || !command.has_command_id()) {
     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()) {
+                command.command_id()) != fetched_command_ids_.end()) {
     return;
   }
 
-  fetched_command_ids_.push_back(command.unique_id());
+  fetched_command_ids_.push_back(command.command_id());
 
   std::unique_ptr<RemoteCommandJob> job =
       factory_->BuildJobForType(command.type());
 
   if (!job || !job->Init(queue_.GetNowTicks(), command)) {
     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());
+    ignored_result.set_command_id(command.command_id());
     unsent_results_.push_back(ignored_result);
     return;
   }
 
   queue_.AddJob(std::move(job));
 }
 
 void RemoteCommandsService::OnJobStarted(RemoteCommandJob* command) {
 }
 
 void RemoteCommandsService::OnJobFinished(RemoteCommandJob* command) {
   has_finished_command_ = true;
   lastest_finished_command_id_ = command->unique_id();
   // TODO(binjin): Attempt to sync |lastest_finished_command_id_| to some
   // persistent source, so that we can reload it later without relying solely on
   // the server to keep our last acknowledged command ID.
   // See http://crbug.com/466572.
 
   em::RemoteCommandResult result;
-  result.set_unique_id(command->unique_id());
+  result.set_command_id(command->unique_id());
   result.set_timestamp((command->execution_started_time() -
                         base::TimeTicks::UnixEpoch()).InMilliseconds());
 
   if (command->status() == RemoteCommandJob::SUCCEEDED ||
       command->status() == RemoteCommandJob::FAILED) {
     if (command->status() == RemoteCommandJob::SUCCEEDED)
       result.set_result(em::RemoteCommandResult_ResultType_RESULT_SUCCESS);
     else
       result.set_result(em::RemoteCommandResult_ResultType_RESULT_FAILURE);
     const std::unique_ptr<std::string> result_payload =
@@ skipping 29 matching lines @@
       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