Browser tests for the new way of handling device ID in Chrome OS.

google_apis/gaia/fake_gaia.cc

 // Copyright (c) 2013 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 "google_apis/gaia/fake_gaia.h"
 
 #include <vector>
 
 #include "base/base_paths.h"
 #include "base/bind.h"
@@ skipping 118 matching lines @@
   : expires_in(3600) {}
 
 FakeGaia::AccessTokenInfo::~AccessTokenInfo() {}
 
 FakeGaia::MergeSessionParams::MergeSessionParams() {
 }
 
 FakeGaia::MergeSessionParams::~MergeSessionParams() {
 }
 
+void FakeGaia::MergeSessionParams::Update(const MergeSessionParams& update) {
+  auto maybe_update_field =
+      [this, &update](std::string MergeSessionParams::*field) {
+        if (!(update.*field).empty())
+          this->*field = update.*field;
+      };
+  maybe_update_field(&MergeSessionParams::auth_sid_cookie);
+  maybe_update_field(&MergeSessionParams::auth_lsid_cookie);
+  maybe_update_field(&MergeSessionParams::auth_code);
+  maybe_update_field(&MergeSessionParams::refresh_token);
+  maybe_update_field(&MergeSessionParams::access_token);
+  maybe_update_field(&MergeSessionParams::gaia_uber_token);
+  maybe_update_field(&MergeSessionParams::session_sid_cookie);
+  maybe_update_field(&MergeSessionParams::session_lsid_cookie);
+  maybe_update_field(&MergeSessionParams::email);
+}
+
 FakeGaia::FakeGaia() : issue_oauth_code_cookie_(false) {
   base::FilePath source_root_dir;
   PathService::Get(base::DIR_SOURCE_ROOT, &source_root_dir);
   CHECK(base::ReadFileToString(
       source_root_dir.Append(base::FilePath(kServiceLogin)),
       &service_login_response_));
   CHECK(base::ReadFileToString(
       source_root_dir.Append(base::FilePath(kEmbeddedSetupChromeos)),
       &embedded_setup_chromeos_response_));
 }
@@ skipping 15 matching lines @@
   params.session_lsid_cookie = kTestSessionLSIDCookie;
   params.email = email;
   SetMergeSessionParams(params);
 }
 
 void FakeGaia::SetMergeSessionParams(
     const MergeSessionParams& params) {
   merge_session_params_ = params;
 }
 
+void FakeGaia::UpdateMergeSessionParams(const MergeSessionParams& params) {
+  merge_session_params_.Update(params);
+}
+
 void FakeGaia::MapEmailToGaiaId(const std::string& email,
                                 const std::string& gaia_id) {
   DCHECK(!email.empty());
   DCHECK(!gaia_id.empty());
   email_to_gaia_id_map_[email] = gaia_id;
 }
 
 std::string FakeGaia::GetGaiaIdOfEmail(const std::string& email) const {
   DCHECK(!email.empty());
   auto it = email_to_gaia_id_map_.find(email);
@@ skipping 115 matching lines @@
 // static
 bool FakeGaia::GetQueryParameter(const std::string& query,
                                  const std::string& key,
                                  std::string* value) {
   // Name and scheme actually don't matter, but are required to get a valid URL
   // for parsing.
   GURL query_url("http://localhost?" + query);
   return net::GetValueForKeyInQuery(query_url, key, value);
 }
 
+std::string FakeGaia::GetDeviceIdByRefreshToken(
+    const std::string& refresh_token) const {
+  auto it = refresh_token_to_device_id_map_.find(refresh_token);

[achuithb, 2015/05/26 06:28:21]

const? Not sure if it works

[dzhioev (left Google), 2015/05/26 21:18:15]

Done.

+  return it != refresh_token_to_device_id_map_.end() ? it->second
+                                                     : std::string();
+}
+
+void FakeGaia::SetRefreshTokenToDeviceIdMap(

[achuithb, 2015/05/26 06:28:21]

Shouldn't this be set_refresh_token_to_device_id_map(), with the inline
implementation in the .h file?

[dzhioev (left Google), 2015/05/26 21:18:15]

Inline setters are only allowed for trivial types.

+    const RefreshTokenToDeviceIdMap& refresh_token_to_device_id_map) {
+  refresh_token_to_device_id_map_ = refresh_token_to_device_id_map;
+}
+
 void FakeGaia::HandleMergeSession(const HttpRequest& request,
                                   BasicHttpResponse* http_response) {
   http_response->set_code(net::HTTP_UNAUTHORIZED);
   if (merge_session_params_.session_sid_cookie.empty() ||
       merge_session_params_.session_lsid_cookie.empty()) {
     http_response->set_code(net::HTTP_BAD_REQUEST);
     return;
   }
 
   std::string uber_token;
@@ skipping 276 matching lines @@
 
   if (grant_type == "authorization_code") {
     std::string auth_code;
     if (!GetQueryParameter(request.content, "code", &auth_code) ||
         auth_code != merge_session_params_.auth_code) {
       http_response->set_code(net::HTTP_BAD_REQUEST);
       LOG(ERROR) << "No 'code' param in /o/oauth2/token";
       return;
     }
 
+    std::string device_id;
+    if (GetQueryParameter(request.content, "device_id", &device_id)) {
+      std::string device_type;
+      if (!GetQueryParameter(request.content, "device_type", &device_type)) {
+        http_response->set_code(net::HTTP_BAD_REQUEST);
+        LOG(ERROR) << "'device_type' should be set if 'device_id' is set.";
+        return;
+      }
+      if (device_type != "chrome") {
+        http_response->set_code(net::HTTP_BAD_REQUEST);
+        LOG(ERROR) << "'device_type' is not 'chrome'.";
+        return;
+      }
+    }
+
     base::DictionaryValue response_dict;
     response_dict.SetString("refresh_token",
                             merge_session_params_.refresh_token);
+    if (!device_id.empty())
+      refresh_token_to_device_id_map_[merge_session_params_.refresh_token] =
+          device_id;
     response_dict.SetString("access_token",
                             merge_session_params_.access_token);
     response_dict.SetInteger("expires_in", 3600);
     FormatJSONResponse(response_dict, http_response);
     return;
   }
 
   std::string scope;
   GetQueryParameter(request.content, "scope", &scope);
 
@@ skipping 94 matching lines @@
   if (token_info) {
     base::DictionaryValue response_dict;
     response_dict.SetString("id", GetGaiaIdOfEmail(token_info->email));
     response_dict.SetString("email", token_info->email);
     response_dict.SetString("verified_email", token_info->email);
     FormatJSONResponse(response_dict, http_response);
   } else {
     http_response->set_code(net::HTTP_BAD_REQUEST);
   }
 }