blob: 947ad5a07f37581ec3713c9596d1e7ce7afe1836 [file] [log] [blame]
// Copyright 2019 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 "remoting/signaling/ftl_grpc_context.h"
#include <utility>
#include "base/guid.h"
#include "base/no_destructor.h"
#include "build/build_config.h"
#include "google_apis/google_api_keys.h"
#include "remoting/base/service_urls.h"
#include "third_party/grpc/src/include/grpcpp/client_context.h"
namespace remoting {
namespace {
constexpr char kChromotingAppIdentifier[] = "CRD";
static base::NoDestructor<GrpcChannelSharedPtr> g_channel_for_testing;
const net::BackoffEntry::Policy kBackoffPolicy = {
// Number of initial errors (in sequence) to ignore before applying
// exponential back-off rules.
0,
// Initial delay for exponential back-off in ms.
FtlGrpcContext::kBackoffInitialDelay.InMilliseconds(),
// Factor by which the waiting time will be multiplied.
2,
// Fuzzing percentage. ex: 10% will spread requests randomly
// between 90%-100% of the calculated time.
0.5,
// Maximum amount of time we are willing to delay our request in ms.
FtlGrpcContext::kBackoffMaxDelay.InMilliseconds(),
// Time to keep an entry from being discarded even when it
// has no significant state, -1 to never discard.
-1,
// Starts with initial delay.
false,
};
} // namespace
constexpr base::TimeDelta FtlGrpcContext::kBackoffInitialDelay;
constexpr base::TimeDelta FtlGrpcContext::kBackoffMaxDelay;
// static
const net::BackoffEntry::Policy& FtlGrpcContext::GetBackoffPolicy() {
return kBackoffPolicy;
}
// static
std::string FtlGrpcContext::GetChromotingAppIdentifier() {
return kChromotingAppIdentifier;
}
// static
ftl::Id FtlGrpcContext::CreateIdFromString(const std::string& ftl_id) {
ftl::Id id;
id.set_id(ftl_id);
id.set_app(GetChromotingAppIdentifier());
// TODO(yuweih): Migrate to IdType.Type.CHROMOTING_ID.
id.set_type(ftl::IdType_Type_EMAIL);
return id;
}
// static
GrpcChannelSharedPtr FtlGrpcContext::CreateChannel() {
if (*g_channel_for_testing) {
return *g_channel_for_testing;
}
return CreateSslChannelForEndpoint(
ServiceUrls::GetInstance()->ftl_server_endpoint());
}
// static
void FtlGrpcContext::FillClientContext(grpc_impl::ClientContext* context) {
#if defined(OS_CHROMEOS)
// Use the default Chrome API key for ChromeOS as the only host instance
// which runs there is used for the ChromeOS Enterprise Kiosk mode
// scenario. If we decide to implement a remote access host for ChromeOS,
// then we will need a way for the caller to provide an API key.
context->AddMetadata("x-goog-api-key", google_apis::GetAPIKey());
#else
context->AddMetadata("x-goog-api-key", google_apis::GetRemotingAPIKey());
#endif
}
// static
ftl::RequestHeader FtlGrpcContext::CreateRequestHeader(
const std::string& ftl_auth_token) {
ftl::RequestHeader header;
header.set_request_id(base::GenerateGUID());
header.set_app(kChromotingAppIdentifier);
if (!ftl_auth_token.empty()) {
header.set_auth_token_payload(ftl_auth_token);
}
ftl::ClientInfo* client_info = header.mutable_client_info();
client_info->set_api_version(ftl::ApiVersion_Value_V4);
client_info->set_version_major(VERSION_MAJOR);
// Chrome's version has four number components, and the VERSION_MINOR is
// always 0, like X.0.X.X. The FTL server requires three-component version
// number so we just skip the VERSION_MINOR here.
client_info->set_version_minor(VERSION_BUILD);
client_info->set_version_point(VERSION_PATCH);
ftl::Platform_Type platform_type;
#if defined(OS_ANDROID)
platform_type = ftl::Platform_Type_FTL_ANDROID;
#elif defined(OS_IOS)
platform_type = ftl::Platform_Type_FTL_IOS;
#else
platform_type = ftl::Platform_Type_FTL_DESKTOP;
#endif
client_info->set_platform_type(platform_type);
return header;
}
// static
void FtlGrpcContext::SetChannelForTesting(GrpcChannelSharedPtr channel) {
*g_channel_for_testing = channel;
}
} // namespace remoting