Hook up CryptAuthGCMManager to the enrollment and device sync managers.

components/proximity_auth/webui/proximity_auth_webui_handler.cc

 // Copyright 2015 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 "components/proximity_auth/webui/proximity_auth_webui_handler.h"
 
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
 #include "base/prefs/pref_service.h"
 #include "base/time/default_clock.h"
 #include "base/values.h"
 #include "components/proximity_auth/cryptauth/base64url.h"
 #include "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h"
+#include "components/proximity_auth/cryptauth/cryptauth_gcm_manager_impl.h"
 #include "components/proximity_auth/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/proximity_auth/logging/logging.h"
 #include "components/proximity_auth/webui/cryptauth_enroller_factory_impl.h"
 #include "components/proximity_auth/webui/proximity_auth_ui_delegate.h"
 #include "content/public/browser/web_ui.h"
 
 namespace proximity_auth {
 
 namespace {
 
@@ skipping 120 matching lines @@
 
   web_ui()->RegisterMessageCallback(
       "forceEnrollment", base::Bind(&ProximityAuthWebUIHandler::ForceEnrollment,
                                     base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       "forceDeviceSync", base::Bind(&ProximityAuthWebUIHandler::ForceDeviceSync,
                                     base::Unretained(this)));
 
   LogBuffer::GetInstance()->AddObserver(this);
+
+  InitGCMManager();
   InitEnrollmentManager();
   InitDeviceManager();
 }
 
 void ProximityAuthWebUIHandler::OnLogMessageAdded(
     const LogBuffer::LogMessage& log_message) {
   scoped_ptr<base::DictionaryValue> dictionary =
       LogMessageToDictionary(log_message);
   web_ui()->CallJavascriptFunction("LogBufferInterface.onLogMessageAdded",
                                    *dictionary);
@@ skipping 69 matching lines @@
     enrollment_manager_->ForceEnrollmentNow(
         cryptauth::INVOCATION_REASON_MANUAL);
   }
 }
 
 void ProximityAuthWebUIHandler::ForceDeviceSync(const base::ListValue* args) {
   if (device_manager_)
     device_manager_->ForceSyncNow(cryptauth::INVOCATION_REASON_MANUAL);
 }
 
+void ProximityAuthWebUIHandler::InitGCMManager() {
+  gcm_manager_.reset(new CryptAuthGCMManagerImpl(delegate_->GetGCMDriver(),
+                                                 delegate_->GetPrefService()));
+}
+
 void ProximityAuthWebUIHandler::InitEnrollmentManager() {
 #if defined(OS_CHROMEOS)
   // TODO(tengs): We initialize a CryptAuthEnrollmentManager here for
   // development and testing purposes until it is ready to be moved into Chrome.
   // The public/private key pair has been generated and serialized in a previous
   // session.
   std::string user_public_key;
   Base64UrlDecode(
       "CAESRgohAD1lP_wgQ8XqVVwz4aK_89SqdvAQG5L_NZH5zXxwg5UbEiEAZFMlgCZ9h8OlyE4"
       "QYKY5oiOBu0FmLSKeTAXEq2jnVJI=",
@@ skipping 34 matching lines @@
       "bF9JVWY4YTJDSmJNbXFqaWpYUFYzaVV5dmJXSVRrR3d1bFRaVUs3RGVZczJtT0h5ZkQ1NWR"
       "HRXEtdnJTdVc4VEZ2Z1haa2xhVEZTN0dqM2xCVUktSHd5Z0h6bHZHX2NGLWtzQmw0dXdveG"
       "VPWE1hRlJ3WGJHVUU1Tm9sLS1mdkRIcGVZVnJR",
       &serialized_device_info);
   cryptauth::GcmDeviceInfo device_info;
   device_info.ParseFromString(serialized_device_info);
 
   enrollment_manager_.reset(new CryptAuthEnrollmentManager(
       make_scoped_ptr(new base::DefaultClock()),
       make_scoped_ptr(new CryptAuthEnrollerFactoryImpl(delegate_)),
-      user_public_key, user_private_key, device_info,
+      user_public_key, user_private_key, device_info, gcm_manager_.get(),
       delegate_->GetPrefService()));
   enrollment_manager_->AddObserver(this);
   enrollment_manager_->Start();
 #endif
 }
 
 void ProximityAuthWebUIHandler::InitDeviceManager() {
   // TODO(tengs): We initialize a CryptAuthDeviceManager here for
   // development and testing purposes until it is ready to be moved into Chrome.
   device_manager_.reset(new CryptAuthDeviceManager(
       make_scoped_ptr(new base::DefaultClock()),
-      delegate_->CreateCryptAuthClientFactory(), delegate_->GetPrefService()));
+      delegate_->CreateCryptAuthClientFactory(), gcm_manager_.get(),
+      delegate_->GetPrefService()));
   device_manager_->AddObserver(this);
   device_manager_->Start();
 }
 
 void ProximityAuthWebUIHandler::OnCryptAuthClientError(
     const std::string& error_message) {
   PA_LOG(WARNING) << "CryptAuth request failed: " << error_message;
   base::StringValue error_string(error_message);
   web_ui()->CallJavascriptFunction("CryptAuthInterface.onError", error_string);
 }
@@ skipping 46 matching lines @@
     return make_scoped_ptr(new base::DictionaryValue());
 
   return CreateSyncStateDictionary(
       device_manager_->GetLastSyncTime().ToJsTime(),
       device_manager_->GetTimeToNextAttempt().InMillisecondsF(),
       device_manager_->IsRecoveringFromFailure(),
       device_manager_->IsSyncInProgress());
 }
 
 }  // namespace proximity_auth