GRPC Stream implementation of HeliumStream

blimp/client/core/session/assignment_source.cc

 // Copyright 2016 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 "blimp/client/core/session/assignment_source.h"
 
 #include <memory>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 100 matching lines @@
 // Must be called on a thread suitable for file IO.
 Assignment GetAssignmentFromCommandLine() {
   Assignment assignment;
 
   const base::CommandLine* cmd_line = base::CommandLine::ForCurrentProcess();
   assignment.client_auth_token = GetClientAuthToken(*cmd_line);
   CHECK(!assignment.client_auth_token.empty())
       << "No client auth token provided.";
 
   unsigned port_parsed = 0;
-  if (!base::StringToUint(
-          cmd_line->GetSwitchValueASCII(switches::kEnginePort),
-          &port_parsed) || !IsValidIpPortNumber(port_parsed)) {
+  if (!base::StringToUint(cmd_line->GetSwitchValueASCII(switches::kEnginePort),
+                          &port_parsed) ||
+      !IsValidIpPortNumber(port_parsed)) {
     DLOG(FATAL) << "--engine-port must be a value between 1 and 65535.";
     return Assignment();
   }
 
   net::IPAddress ip_address;
   std::string ip_str = cmd_line->GetSwitchValueASCII(switches::kEngineIP);
   if (!ip_address.AssignFromIPLiteral(ip_str)) {
     DLOG(FATAL) << "Invalid engine IP " << ip_str;
     return Assignment();
   }
-  assignment.engine_endpoint =
+  assignment.assignment_options.engine_endpoint =
       net::IPEndPoint(ip_address, base::checked_cast<uint16_t>(port_parsed));
 
   std::string transport_str =
       cmd_line->GetSwitchValueASCII(switches::kEngineTransport);
   if (transport_str == kSSLTransportValue) {
     assignment.transport_protocol = Assignment::TransportProtocol::SSL;
   } else if (transport_str == kTCPTransportValue) {
     assignment.transport_protocol = Assignment::TransportProtocol::TCP;
   } else if (transport_str == kGrpcTransportValue) {
     assignment.transport_protocol = Assignment::TransportProtocol::GRPC;
@@ skipping 214 matching lines @@
   if (cert_list.size() != 1) {
     base::ResetAndReturn(&callback_)
         .Run(ASSIGNMENT_REQUEST_RESULT_INVALID_CERT, Assignment());
     return;
   }
 
   // The assigner assumes SSL-only and all engines it assigns only communicate
   // over SSL.
   Assignment assignment;
   assignment.transport_protocol = Assignment::TransportProtocol::SSL;
-  assignment.engine_endpoint = net::IPEndPoint(ip_address, port);
+  assignment.assignment_options.engine_endpoint =
+      net::IPEndPoint(ip_address, port);
   assignment.client_auth_token = client_auth_token;
   assignment.cert = std::move(cert_list[0]);
 
   base::ResetAndReturn(&callback_)
       .Run(ASSIGNMENT_REQUEST_RESULT_OK, assignment);
 }
 
 void AssignmentSource::OnJsonParseError(const std::string& error) {
   DLOG(ERROR) << "Error while parsing assigner JSON: " << error;
   base::ResetAndReturn(&callback_)
       .Run(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, Assignment());
 }
 
 }  // namespace client
 }  // namespace blimp