Remove AccessVerifier interface.

remoting/host/plugin/host_script_object.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 "remoting/host/plugin/host_script_object.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/sys_string_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "remoting/base/auth_token_util.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/host_config.h"
 #include "remoting/host/host_key_pair.h"
+#include "remoting/host/host_secret.h"
 #include "remoting/host/in_memory_host_config.h"
 #include "remoting/host/plugin/host_log_handler.h"
 #include "remoting/host/plugin/policy_hack/nat_policy.h"
 #include "remoting/host/register_support_host_request.h"
-#include "remoting/host/support_access_verifier.h"
 
 namespace remoting {
 
 // Supported Javascript interface:
 // readonly attribute string accessCode;
 // readonly attribute int accessCodeLifetime;
 // readonly attribute string client;
 // readonly attribute int state;
 //
 // state: {
@@ skipping 439 matching lines @@
     // Host has been stopped while we were fetching policy.
     return;
   }
 
   // Store the supplied user ID and token to the Host configuration.
   scoped_refptr<MutableHostConfig> host_config = new InMemoryHostConfig();
   host_config->SetString(kXmppLoginConfigPath, uid);
   host_config->SetString(kXmppAuthTokenConfigPath, auth_token);
   host_config->SetString(kXmppAuthServiceConfigPath, auth_service);
 
-  // Create an access verifier and fetch the host secret.
-  scoped_ptr<SupportAccessVerifier> access_verifier;
-  access_verifier.reset(new SupportAccessVerifier());
-
   // Generate a key pair for the Host to use.
   // TODO(wez): Move this to the worker thread.
   HostKeyPair host_key_pair;
   host_key_pair.Generate();
   host_key_pair.Save(host_config);
 
   // Request registration of the host for support.
   scoped_ptr<RegisterSupportHostRequest> register_request(
       new RegisterSupportHostRequest());
   if (!register_request->Init(
           host_config.get(),
           base::Bind(&HostNPScriptObject::OnReceivedSupportID,
-                     base::Unretained(this),
-                     access_verifier.get()))) {
+                     base::Unretained(this)))) {
     SetState(kError);
     return;
   }
 
   // Create DesktopEnvironment.
   desktop_environment_.reset(DesktopEnvironment::Create(&host_context_));
   if (desktop_environment_.get() == NULL) {
     SetState(kError);
     return;
   }
 
   // Beyond this point nothing can fail, so save the config and request.
   host_config_ = host_config;
   register_request_.reset(register_request.release());
 
   // Create the Host.
   LOG(INFO) << "NAT state: " << nat_traversal_enabled_;
   host_ = ChromotingHost::Create(
       &host_context_, host_config_, desktop_environment_.get(),
-      access_verifier.release(), nat_traversal_enabled_);
+      nat_traversal_enabled_);
   host_->AddStatusObserver(this);
   host_->AddStatusObserver(register_request_.get());
   if (enable_log_to_server_) {
     log_to_server_.reset(new LogToServer(host_context_.network_message_loop()));
     host_->AddStatusObserver(log_to_server_.get());
   }
   host_->set_it2me(true);
 
   {
     base::AutoLock auto_lock(ui_strings_lock_);
@@ skipping 106 matching lines @@
 
   UpdateWebappNatPolicy(nat_traversal_enabled_);
 
   if (!pending_connect_.is_null()) {
     pending_connect_.Run();
     pending_connect_.Reset();
   }
 }
 
 void HostNPScriptObject::OnReceivedSupportID(
-    SupportAccessVerifier* access_verifier,
     bool success,
     const std::string& support_id,
     const base::TimeDelta& lifetime) {
   DCHECK(host_context_.network_message_loop()->BelongsToCurrentThread());
 
   if (!success) {
     host_context_.main_message_loop()->PostTask(FROM_HERE, base::Bind(
         &HostNPScriptObject::NotifyAccessCode, base::Unretained(this), false));
     DisconnectInternal();
     return;
   }
 
-  access_verifier->OnIT2MeHostRegistered(success, support_id);
-  std::string access_code = support_id + access_verifier->host_secret();
+  std::string host_secret = GenerateSupportHostSecret();
+  std::string access_code = support_id + host_secret;
   host_->set_access_code(access_code);
 
   {
     base::AutoLock lock(access_code_lock_);
     access_code_ = access_code;
     access_code_lifetime_ = lifetime;
   }
 
   host_context_.main_message_loop()->PostTask(FROM_HERE, base::Bind(
       &HostNPScriptObject::NotifyAccessCode, base::Unretained(this), true));
@@ skipping 171 matching lines @@
                                                uint32_t argCount) {
   NPVariant np_result;
   bool is_good = g_npnetscape_funcs->invokeDefault(plugin_, func, args,
                                                    argCount, &np_result);
   if (is_good)
       g_npnetscape_funcs->releasevariantvalue(&np_result);
   return is_good;
 }
 
 }  // namespace remoting