Remove AccessVerifier interface.

remoting/host/simple_host_process.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.
 //
 // This is an application of a minimal host process in a Chromoting
 // system. It serves the purpose of gluing different pieces together
 // to make a functional host process for testing.
 //
 // It peforms the following functionality:
 // 1. Connect to the GTalk network and register the machine as a host.
@@ skipping 23 matching lines @@
 #include "remoting/base/constants.h"
 #include "remoting/host/capturer_fake.h"
 #include "remoting/host/chromoting_host.h"
 #include "remoting/host/chromoting_host_context.h"
 #include "remoting/host/continue_window.h"
 #include "remoting/host/curtain.h"
 #include "remoting/host/desktop_environment.h"
 #include "remoting/host/disconnect_window.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/heartbeat_sender.h"
+#include "remoting/host/host_secret.h"
 #include "remoting/host/local_input_monitor.h"
 #include "remoting/host/log_to_server.h"
 #include "remoting/host/json_host_config.h"
 #include "remoting/host/register_support_host_request.h"
-#include "remoting/host/self_access_verifier.h"
-#include "remoting/host/support_access_verifier.h"
 #include "remoting/proto/video.pb.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include "ui/gfx/gtk_util.h"
 #elif defined(OS_MACOSX)
 #include "base/mac/scoped_nsautorelease_pool.h"
 #elif defined(OS_WIN)
 // TODO(garykac) Make simple host into a proper GUI app on Windows so that we
 // have an hModule for the dialog resource.
 HMODULE g_hModule = NULL;
@@ skipping 66 matching lines @@
     // the account.
     config->SetString(kXmppAuthServiceConfigPath,
                       kChromotingTokenDefaultServiceName);
 
     // Initialize AccessVerifier.
     // TODO(jamiewalch): For the IT2Me case, the access verifier is passed to
     // RegisterSupportHostRequest::Init, so transferring ownership of it to the
     // ChromotingHost could cause a crash condition if SetIT2MeAccessCode is
     // called after the ChromotingHost is destroyed (for example, at shutdown).
     // Fix this.
-    scoped_ptr<remoting::AccessVerifier> access_verifier;
     scoped_ptr<remoting::RegisterSupportHostRequest> register_request;
     scoped_ptr<remoting::HeartbeatSender> heartbeat_sender;
     scoped_ptr<remoting::LogToServer> log_to_server;
     if (is_it2me_) {
-      scoped_ptr<remoting::SupportAccessVerifier> support_access_verifier(
-          new remoting::SupportAccessVerifier());
       register_request.reset(new remoting::RegisterSupportHostRequest());
       if (!register_request->Init(
               config, base::Bind(&SimpleHost::SetIT2MeAccessCode,
-                                 base::Unretained(this),
-                                 support_access_verifier.get()))) {
+                                 base::Unretained(this)))) {
         return 1;
       }
-      access_verifier.reset(support_access_verifier.release());
-    } else {
-      scoped_ptr<remoting::SelfAccessVerifier> self_access_verifier(
-          new remoting::SelfAccessVerifier());
-      if (!self_access_verifier->Init(config))
-        return 1;
-      access_verifier.reset(self_access_verifier.release());
     }
     log_to_server.reset(new remoting::LogToServer(
         context.network_message_loop()));
 
     // Construct a chromoting host.
     scoped_ptr<DesktopEnvironment> desktop_environment;
     if (fake_) {
       remoting::Capturer* capturer =
           new remoting::CapturerFake();
       remoting::EventExecutor* event_executor =
           remoting::EventExecutor::Create(context.desktop_message_loop(),
                                           capturer);
       remoting::Curtain* curtain = remoting::Curtain::Create();
       remoting::DisconnectWindow* disconnect_window =
           remoting::DisconnectWindow::Create();
       remoting::ContinueWindow* continue_window =
           remoting::ContinueWindow::Create();
       remoting::LocalInputMonitor* local_input_monitor =
           remoting::LocalInputMonitor::Create();
       desktop_environment.reset(
           new DesktopEnvironment(&context, capturer, event_executor, curtain,
                                  disconnect_window, continue_window,
                                  local_input_monitor));
     } else {
       desktop_environment.reset(DesktopEnvironment::Create(&context));
     }
 
-    host_ = ChromotingHost::Create(&context, config, desktop_environment.get(),
-                                   access_verifier.release(), false);
+    host_ = ChromotingHost::Create(
+        &context, config, desktop_environment.get(), false);
     host_->set_it2me(is_it2me_);
 
     if (protocol_config_.get()) {
       host_->set_protocol_config(protocol_config_.release());
     }
 
     if (is_it2me_) {
       host_->AddStatusObserver(register_request.get());
     } else {
       // Initialize HeartbeatSender.
@@ skipping 24 matching lines @@
   }
   void set_fake(bool fake) { fake_ = fake; }
   void set_is_it2me(bool is_it2me) { is_it2me_ = is_it2me; }
   void set_protocol_config(CandidateSessionConfig* protocol_config) {
     protocol_config_.reset(protocol_config);
   }
 
  private:
   // TODO(wez): This only needs to be a member because it needs access to the
   // ChromotingHost, which has to be created after the SupportAccessVerifier.
-  void SetIT2MeAccessCode(remoting::SupportAccessVerifier* access_verifier,
-                          bool successful, const std::string& support_id,
+  void SetIT2MeAccessCode(bool successful, const std::string& support_id,
                           const base::TimeDelta& lifetime) {
-    access_verifier->OnIT2MeHostRegistered(successful, support_id);
     if (successful) {
-      std::string access_code = support_id + access_verifier->host_secret();
+      std::string host_secret = remoting::GenerateSupportHostSecret();
+      std::string access_code = support_id + host_secret;
       std::cout << "Support id: " << access_code << std::endl;
 
       // Tell the ChromotingHost the access code, to use as shared-secret.
       host_->set_access_code(access_code);
     } else {
       LOG(ERROR) << "If you haven't done so recently, try running"
                  << " remoting/tools/register_host.py.";
     }
   }
 
@@ skipping 65 matching lines @@
       LOG(ERROR) << "Unknown video codec: " << video_codec;
       return 1;
     }
     config->mutable_video_configs()->push_back(ChannelConfig(
         transport, remoting::protocol::kDefaultStreamVersion, codec));
     simple_host.set_protocol_config(config.release());
   }
 
   return simple_host.Run();
 }