Add AssignmentSource to BlimpClientContextImpl

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 "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
@@ skipping 150 matching lines @@
   if (!assignment.IsValid()) {
     DLOG(FATAL) << "Invalid command-line assignment.";
     return Assignment();
   }
 
   return assignment;
 }
 
 }  // namespace
 
-Assignment::Assignment() : transport_protocol(TransportProtocol::UNKNOWN) {}
-
-Assignment::Assignment(const Assignment& other) = default;
-
-Assignment::~Assignment() {}
-
-bool Assignment::IsValid() const {
-  if (engine_endpoint.address().empty() || engine_endpoint.port() == 0 ||
-      transport_protocol == TransportProtocol::UNKNOWN) {
-    return false;
-  }
-  if (transport_protocol == TransportProtocol::SSL && !cert) {
-    return false;
-  }
-  return true;
-}
-
 AssignmentSource::AssignmentSource(
     const GURL& assigner_endpoint,
     const scoped_refptr<base::SingleThreadTaskRunner>& network_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner)
     : assigner_endpoint_(assigner_endpoint),
       file_task_runner_(std::move(file_task_runner)),
       url_request_context_(
           new SimpleURLRequestContextGetter(network_task_runner)),
       weak_factory_(this) {
   DCHECK(assigner_endpoint_.is_valid());
@@ skipping 16 matching lines @@
     QueryAssigner(client_auth_token);
   }
 }
 
 void AssignmentSource::OnGetAssignmentFromCommandLineDone(
     const std::string& client_auth_token,
     Assignment parsed_assignment) {
   // If GetAssignmentFromCommandLine succeeded, then return its output.
   if (parsed_assignment.IsValid()) {
     base::ResetAndReturn(&callback_)
-        .Run(AssignmentSource::RESULT_OK, parsed_assignment);
+        .Run(ASSIGNMENT_REQUEST_RESULT_OK, parsed_assignment);
     return;
   }
 
   // If no assignment was passed via the command line, then fall back on
   // querying the Assigner service.
   QueryAssigner(client_auth_token);
 }
 
 void AssignmentSource::QueryAssigner(const std::string& client_auth_token) {
   // Call out to the network for a real assignment.  Build the network request
@@ skipping 17 matching lines @@
 }
 
 void AssignmentSource::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK(!callback_.is_null());
   DCHECK_EQ(url_fetcher_.get(), source);
 
   if (!source->GetStatus().is_success()) {
     DVLOG(1) << "Assignment request failed due to network error: "
              << net::ErrorToString(source->GetStatus().error());
     base::ResetAndReturn(&callback_)
-        .Run(AssignmentSource::Result::RESULT_NETWORK_FAILURE, Assignment());
+        .Run(ASSIGNMENT_REQUEST_RESULT_NETWORK_FAILURE, Assignment());
     return;
   }
 
   switch (source->GetResponseCode()) {
     case net::HTTP_OK:
       ParseAssignerResponse();
       break;
     case net::HTTP_BAD_REQUEST:
       base::ResetAndReturn(&callback_)
-          .Run(AssignmentSource::Result::RESULT_BAD_REQUEST, Assignment());
+          .Run(ASSIGNMENT_REQUEST_RESULT_BAD_REQUEST, Assignment());
       break;
     case net::HTTP_UNAUTHORIZED:
       base::ResetAndReturn(&callback_)
-          .Run(AssignmentSource::Result::RESULT_EXPIRED_ACCESS_TOKEN,
-               Assignment());
+          .Run(ASSIGNMENT_REQUEST_RESULT_EXPIRED_ACCESS_TOKEN, Assignment());
       break;
     case net::HTTP_FORBIDDEN:
       base::ResetAndReturn(&callback_)
-          .Run(AssignmentSource::Result::RESULT_USER_INVALID, Assignment());
+          .Run(ASSIGNMENT_REQUEST_RESULT_USER_INVALID, Assignment());
       break;
     case 429:  // Too Many Requests
       base::ResetAndReturn(&callback_)
-          .Run(AssignmentSource::Result::RESULT_OUT_OF_VMS, Assignment());
+          .Run(ASSIGNMENT_REQUEST_RESULT_OUT_OF_VMS, Assignment());
       break;
     case net::HTTP_INTERNAL_SERVER_ERROR:
       base::ResetAndReturn(&callback_)
-          .Run(AssignmentSource::Result::RESULT_SERVER_ERROR, Assignment());
+          .Run(ASSIGNMENT_REQUEST_RESULT_SERVER_ERROR, Assignment());
       break;
     default:
+      LOG(WARNING) << "Defaulting to BAD_RESPONSE for HTTP response code "
+                   << source->GetResponseCode();
       base::ResetAndReturn(&callback_)
-          .Run(AssignmentSource::Result::RESULT_BAD_RESPONSE, Assignment());
+          .Run(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, Assignment());
       break;
   }
 }
 
 void AssignmentSource::ParseAssignerResponse() {
   DCHECK(url_fetcher_.get());
   DCHECK(url_fetcher_->GetStatus().is_success());
   DCHECK_EQ(net::HTTP_OK, url_fetcher_->GetResponseCode());
 
   // Grab the response from the assigner request.
   std::string response;
   if (!url_fetcher_->GetResponseAsString(&response)) {
+    LOG(WARNING) << "Unable to retrieve response as string from URLFetcher.";
     base::ResetAndReturn(&callback_)
-        .Run(AssignmentSource::Result::RESULT_BAD_RESPONSE, Assignment());
+        .Run(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, Assignment());
     return;
   }
 
   safe_json::SafeJsonParser::Parse(
       response,
       base::Bind(&AssignmentSource::OnJsonParsed, weak_factory_.GetWeakPtr()),
       base::Bind(&AssignmentSource::OnJsonParseError,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AssignmentSource::OnJsonParsed(std::unique_ptr<base::Value> json) {
   const base::DictionaryValue* dict;
   if (!json->GetAsDictionary(&dict)) {
+    LOG(WARNING) << "Unable to parse JSON data as a dictionary.";
     base::ResetAndReturn(&callback_)
-        .Run(AssignmentSource::Result::RESULT_BAD_RESPONSE, Assignment());
+        .Run(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, Assignment());
     return;
   }
 
   // Validate that all the expected fields are present.
   std::string client_token;
   std::string host;
   int port;
   std::string cert_str;
   if (!(dict->GetString(kClientTokenKey, &client_token) &&
         dict->GetString(kHostKey, &host) && dict->GetInteger(kPortKey, &port) &&
         dict->GetString(kCertificateKey, &cert_str))) {
+    LOG(WARNING) << "Not all fields present in assignment JSON data.";
     base::ResetAndReturn(&callback_)
-        .Run(AssignmentSource::Result::RESULT_BAD_RESPONSE, Assignment());
+        .Run(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, Assignment());
     return;
   }
 
   net::IPAddress ip_address;
   if (!ip_address.AssignFromIPLiteral(host)) {
+    LOG(WARNING) << "Unable to assign IP address from string literal " << host;
     base::ResetAndReturn(&callback_)
-        .Run(AssignmentSource::Result::RESULT_BAD_RESPONSE, Assignment());
+        .Run(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, Assignment());
     return;
   }
 
   if (!base::IsValueInRangeForNumericType<uint16_t>(port)) {
+    LOG(WARNING) << "Assignment port number not in range for uint16_t";
     base::ResetAndReturn(&callback_)
-        .Run(AssignmentSource::Result::RESULT_BAD_RESPONSE, Assignment());
+        .Run(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, Assignment());
     return;
   }
 
   net::CertificateList cert_list =
       net::X509Certificate::CreateCertificateListFromBytes(
           cert_str.data(), cert_str.size(),
           net::X509Certificate::FORMAT_PEM_CERT_SEQUENCE);
   if (cert_list.size() != 1) {
     base::ResetAndReturn(&callback_)
-        .Run(AssignmentSource::Result::RESULT_INVALID_CERT, Assignment());
+        .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.client_token = client_token;
   assignment.cert = std::move(cert_list[0]);
 
   base::ResetAndReturn(&callback_)
-      .Run(AssignmentSource::Result::RESULT_OK, assignment);
+      .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(AssignmentSource::Result::RESULT_BAD_RESPONSE, Assignment());
+      .Run(ASSIGNMENT_REQUEST_RESULT_BAD_RESPONSE, Assignment());
 }
 
 }  // namespace client
 }  // namespace blimp