Fix use of SupportAccessVerifier in Host plugin.

remoting/host/host_plugin.cc

 // Copyright (c) 2011 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 <stdio.h>
 #include <string.h>
 
 #include <string>
 #include <vector>
 
@@ skipping 293 matching lines @@
   int state_;
   std::string access_code_;
   NPObject* on_state_changed_func_;
   base::AtExitManager exit_manager_;
   base::PlatformThreadId np_thread_id_;
 
   scoped_refptr<remoting::RegisterSupportHostRequest> register_request_;
   scoped_refptr<remoting::ChromotingHost> host_;
   scoped_refptr<remoting::MutableHostConfig> host_config_;
   remoting::ChromotingHostContext host_context_;
-  std::string host_secret_;
 
   // Start connection. args are:
   //   string uid, string auth_token
   // No result.
   bool Connect(const NPVariant* args, uint32_t argCount, NPVariant* result);
 
   // Disconnect. No arguments or result.
   bool Disconnect(const NPVariant* args, uint32_t argCount, NPVariant* result);
 
   // Call OnStateChanged handler if there is one.
   void OnStateChanged(State state);
 
-  // Currently just mock methods to verify that everything is working
-  void OnReceivedSupportID(bool success, const std::string& support_id);
+  // Callbacks invoked during session setup.
+  void OnReceivedSupportID(remoting::SupportAccessVerifier* access_verifier,
+                           bool success,
+                           const std::string& support_id);
   void OnConnected();
   void OnHostShutdown();
 
   // Call a JavaScript function wrapped as an NPObject.
   // If result is non-null, the result of the call will be stored in it.
   // Caller is responsible for releasing result if they ask for it.
   static bool CallJSFunction(NPObject* func,
                              const NPVariant* args,
                              uint32_t argCount,
                              NPVariant* result);
@@ skipping 53 matching lines @@
   host_config->SetString(remoting::kXmppLoginConfigPath, uid);
   host_config->SetString(remoting::kXmppAuthTokenConfigPath, auth_token);
 
   // Create an access verifier and fetch the host secret.
   scoped_ptr<remoting::SupportAccessVerifier> access_verifier;
   access_verifier.reset(new remoting::SupportAccessVerifier);
   if (!access_verifier->Init()) {
     SetException("connect: SupportAccessVerifier::Init failed");
     return false;
   }
-  host_secret_ = access_verifier->host_secret();
 
   // Generate a key pair for the Host to use.
   // TODO(wez): Move this to the worker thread.
   remoting::HostKeyPair host_key_pair;
   host_key_pair.Generate();
   host_key_pair.Save(host_config);
 
-  // Create the Host.
-  scoped_refptr<remoting::ChromotingHost> host =
-      remoting::ChromotingHost::Create(&host_context_, host_config,
-                                       access_verifier.release());
-
   // Request registration of the host for support.
   scoped_refptr<remoting::RegisterSupportHostRequest> register_request =
       new remoting::RegisterSupportHostRequest();
   if (!register_request->Init(
           host_config.get(),
           base::Bind(&HostNPScriptObject::OnReceivedSupportID,
-                     base::Unretained(this)))) {
+                     base::Unretained(this),
+                     access_verifier.get()))) {
     SetException("connect: RegisterSupportHostRequest::Init failed");
     return false;
   }
+
+  // Create the Host.
+  scoped_refptr<remoting::ChromotingHost> host =
+      remoting::ChromotingHost::Create(&host_context_, host_config,
+                                       access_verifier.release());
   host->AddStatusObserver(register_request);
 
+  // TODO(wez): Improve our authentication framework.
+  host->set_preauthenticated(true);
+
   // Nothing went wrong, so lets save the host, config and request.
   host_ = host;
   host_config_ = host_config;
   register_request_ = register_request;
 
   // Start the Host.
   // TODO(wez): Attach to the Host for notifications of state changes.
   // It currently has no interface for that, though.
   host_->Start(NewRunnableMethod(this, &HostNPScriptObject::OnHostShutdown));
 
   OnStateChanged(kRequestedAccessCode);
   return true;
 }
 
 bool HostNPScriptObject::Disconnect(const NPVariant* args,
                                     uint32_t arg_count,
                                     NPVariant* result) {
   CHECK_EQ(base::PlatformThread::CurrentId(), np_thread_id_);
   if (arg_count != 0) {
     SetException("disconnect: bad number of arguments");
     return false;
   }
 
   if (host_.get()) {
     host_->Shutdown();
     host_ = NULL;
   }
   register_request_ = NULL;
   host_config_ = NULL;
-  host_secret_.clear();
 
   OnStateChanged(kDisconnected);
   return true;
 }
 
-void HostNPScriptObject::OnReceivedSupportID(bool success,
-                                             const std::string& support_id) {
+void HostNPScriptObject::OnReceivedSupportID(
+    remoting::SupportAccessVerifier* access_verifier,
+    bool success,
+    const std::string& support_id) {
   CHECK_NE(base::PlatformThread::CurrentId(), np_thread_id_);
 
   if (!success) {
     // TODO(wez): Replace the success/fail flag with full error reporting.
     OnHostShutdown();
     return;
   }
 
-  // Combine the Support Id with the Host Id to make the Access Code
+  // Inform the AccessVerifier of our Support-Id, for authentication.
+  access_verifier->OnMe2MomHostRegistered(success, support_id);
+
+  // Combine the Support Id with the Host Id to make the Access Code.
   // TODO(wez): Locking, anyone?
-  access_code_ = support_id + "-" + host_secret_;
-  host_secret_ = std::string();
+  access_code_ = support_id + "-" + access_verifier->host_secret();
 
   // Let the caller know that life is good.
   OnStateChanged(kReceivedAccessCode);
 }
 
 void HostNPScriptObject::OnConnected() {
   CHECK_NE(base::PlatformThread::CurrentId(), np_thread_id_);
   OnStateChanged(kConnected);
 }
 
@@ skipping 378 matching lines @@
   return STRINGIZE(HOST_PLUGIN_MIME_TYPE) ":"
       HOST_PLUGIN_NAME ":"
       HOST_PLUGIN_DESCRIPTION;
 }
 
 OSCALL NPError NP_GetValue(void* npp, NPPVariable variable, void* value) {
   return GetValue((NPP)npp, variable, value);
 }
 
 }  // extern "C"