Supervised user SafeSites: Expose & use API key from src-internal

google_apis/google_api_keys.cc

 // Copyright (c) 2012 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/google_api_keys.h"
 
 // If you add more includes to this list, you also need to add them to
 // google_api_keys_unittest.cc.
 #include "base/command_line.h"
 #include "base/environment.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/stringize_macros.h"
 #include "google_apis/gaia/gaia_switches.h"
 
 #if defined(GOOGLE_CHROME_BUILD) || defined(USE_OFFICIAL_GOOGLE_API_KEYS)
 #include "google_apis/internal/google_chrome_api_keys.h"
 #endif
 
 // Used to indicate an unset key/id/secret.  This works better with
 // various unit tests than leaving the token empty.
 #define DUMMY_API_TOKEN "dummytoken"
 
 #if !defined(GOOGLE_API_KEY)
 #define GOOGLE_API_KEY DUMMY_API_TOKEN
 #endif
 
+#if !defined(GOOGLE_API_KEY_SAFESITES)
+#define GOOGLE_API_KEY_SAFESITES DUMMY_API_TOKEN
+#endif
+
 #if !defined(GOOGLE_CLIENT_ID_MAIN)
 #define GOOGLE_CLIENT_ID_MAIN DUMMY_API_TOKEN
 #endif
 
 #if !defined(GOOGLE_CLIENT_SECRET_MAIN)
 #define GOOGLE_CLIENT_SECRET_MAIN DUMMY_API_TOKEN
 #endif
 
 #if !defined(GOOGLE_CLIENT_ID_CLOUD_PRINT)
 #define GOOGLE_CLIENT_ID_CLOUD_PRINT DUMMY_API_TOKEN
@@ skipping 40 matching lines @@
     scoped_ptr<base::Environment> environment(base::Environment::Create());
     CommandLine* command_line = CommandLine::ForCurrentProcess();
 
     api_key_ = CalculateKeyValue(GOOGLE_API_KEY,
                                  STRINGIZE_NO_EXPANSION(GOOGLE_API_KEY),
                                  NULL,
                                  std::string(),
                                  environment.get(),
                                  command_line);
 
+    api_key_safesites_ =
+        CalculateKeyValue(GOOGLE_API_KEY_SAFESITES,
+                          STRINGIZE_NO_EXPANSION(GOOGLE_API_KEY_SAFESITES),
+                          NULL,
+                          std::string(),
+                          environment.get(),
+                          command_line);
+
     std::string default_client_id =
         CalculateKeyValue(GOOGLE_DEFAULT_CLIENT_ID,
                           STRINGIZE_NO_EXPANSION(GOOGLE_DEFAULT_CLIENT_ID),
                           NULL,
                           std::string(),
                           environment.get(),
                           command_line);
     std::string default_client_secret =
         CalculateKeyValue(GOOGLE_DEFAULT_CLIENT_SECRET,
                           STRINGIZE_NO_EXPANSION(GOOGLE_DEFAULT_CLIENT_SECRET),
@@ skipping 63 matching lines @@
     client_secrets_[CLIENT_REMOTING_HOST] = CalculateKeyValue(
         GOOGLE_CLIENT_SECRET_REMOTING_HOST,
         STRINGIZE_NO_EXPANSION(GOOGLE_CLIENT_SECRET_REMOTING_HOST),
         NULL,
         default_client_secret,
         environment.get(),
         command_line);
   }
 
   std::string api_key() const { return api_key_; }
+  std::string api_key_safesites() const { return api_key_safesites_; }
 
   std::string GetClientID(OAuth2Client client) const {
     DCHECK_LT(client, CLIENT_NUM_ITEMS);
     return client_ids_[client];
   }
 
   std::string GetClientSecret(OAuth2Client client) const {
     DCHECK_LT(client, CLIENT_NUM_ITEMS);
     return client_secrets_[client];
   }
@@ skipping 45 matching lines @@
       }
     }
 
     // This should remain a debug-only log.
     DVLOG(1) << "API key " << environment_variable_name << "=" << key_value;
 
     return key_value;
   }
 
   std::string api_key_;
+  std::string api_key_safesites_;
   std::string client_ids_[CLIENT_NUM_ITEMS];
   std::string client_secrets_[CLIENT_NUM_ITEMS];
 };
 
 static base::LazyInstance<APIKeyCache> g_api_key_cache =
     LAZY_INSTANCE_INITIALIZER;
 
 bool HasKeysConfigured() {
   if (GetAPIKey() == DUMMY_API_TOKEN)
     return false;
 
   for (size_t client_id = 0; client_id < CLIENT_NUM_ITEMS; ++client_id) {
     OAuth2Client client = static_cast<OAuth2Client>(client_id);
     if (GetOAuth2ClientID(client) == DUMMY_API_TOKEN ||
         GetOAuth2ClientSecret(client) == DUMMY_API_TOKEN) {
       return false;
     }
   }
 
   return true;
 }
 
 std::string GetAPIKey() {
   return g_api_key_cache.Get().api_key();
 }
 
+std::string GetSafeSitesAPIKey() {
+  return g_api_key_cache.Get().api_key_safesites();
+}
+
 std::string GetOAuth2ClientID(OAuth2Client client) {
   return g_api_key_cache.Get().GetClientID(client);
 }
 
 std::string GetOAuth2ClientSecret(OAuth2Client client) {
   return g_api_key_cache.Get().GetClientSecret(client);
 }
 
 std::string GetSpdyProxyAuthValue() {
   return g_api_key_cache.Get().GetSpdyProxyAuthValue();
 }
 
 bool IsGoogleChromeAPIKeyUsed() {
 #if defined(GOOGLE_CHROME_BUILD) || defined(USE_OFFICIAL_GOOGLE_API_KEYS)
   return true;
 #else
   return false;
 #endif
 }
 
 }  // namespace google_apis