Refactor ContinueWindow::Show() to accept a callback parameter.

remoting/host/desktop_environment.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/desktop_environment.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "remoting/host/capturer.h"
 #include "remoting/host/chromoting_host.h"
@@ skipping 90 matching lines @@
   ui_thread_proxy_.PostTask(FROM_HERE, base::Bind(
       &DesktopEnvironment::ProcessOnConnect, base::Unretained(this), username));
 }
 
 void DesktopEnvironment::OnLastDisconnect() {
   ui_thread_proxy_.PostTask(FROM_HERE, base::Bind(
       &DesktopEnvironment::ProcessOnLastDisconnect, base::Unretained(this)));
 }
 
 void DesktopEnvironment::OnPause(bool pause) {
-  ui_thread_proxy_.PostTask(FROM_HERE, base::Bind(
-      &DesktopEnvironment::ProcessOnPause, base::Unretained(this), pause));
 }
 
 void DesktopEnvironment::ProcessOnConnect(const std::string& username) {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   MonitorLocalInputs(true);
   ShowDisconnectWindow(true, username);
   StartContinueWindowTimer(true);
 }
 
 void DesktopEnvironment::ProcessOnLastDisconnect() {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   MonitorLocalInputs(false);
   ShowDisconnectWindow(false, std::string());
   ShowContinueWindow(false);
   StartContinueWindowTimer(false);
 }
 
-void DesktopEnvironment::ProcessOnPause(bool pause) {
-  if (!pause) {
-    timer_task_.reset();
-    StartContinueWindowTimer(true);
-  }
-}
-
 void DesktopEnvironment::MonitorLocalInputs(bool enable) {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   if (enable == is_monitoring_local_inputs_)
     return;
   if (enable) {
     local_input_monitor_->Start(host_);
   } else {
     local_input_monitor_->Stop();
   }
   is_monitoring_local_inputs_ = enable;
 }
 
 void DesktopEnvironment::ShowDisconnectWindow(bool show,
                                               const std::string& username) {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   if (show) {
     disconnect_window_->Show(host_, username);
   } else {
     disconnect_window_->Hide();
   }
 }
 
 void DesktopEnvironment::ShowContinueWindow(bool show) {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   if (show) {
-    continue_window_->Show(host_);
+    continue_window_->Show(host_, base::Bind(
+        &DesktopEnvironment::ContinueSession, base::Unretained(this)));

[Wez, 2011/11/23 18:26:02]

The intent is for ShowContinueWindow() and ContinueSession() to be moved out of
DesktopEnvironment in a follow-up CL, right?

[Lambros, 2011/11/23 19:39:28]

Yep.

   } else {
     continue_window_->Hide();
   }
 }
 
+void DesktopEnvironment::ContinueSession(bool continue_session) {
+  DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
+
+  if (continue_session) {
+    host_->PauseSession(false);
+    timer_task_.reset();
+    StartContinueWindowTimer(true);
+  } else {
+    host_->Shutdown(base::Closure());

[Wez, 2011/11/23 18:26:02]

Shouldn't this be a call to OnShutdownHostTimer(), for consistency?

[Lambros, 2011/11/23 19:39:28]

It could be.  I simply copied the implementation straight out of the
ContinueWindowXxx classes.  I'll do a followup CL for this, and any other
cleanups I notice after the refactoring.

+  }
+}
+
 void DesktopEnvironment::StartContinueWindowTimer(bool start) {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   if (start) {
     timer_task_.reset(new TimerTask(
         context_->ui_message_loop(),
         base::Bind(&DesktopEnvironment::OnContinueWindowTimer,
                    base::Unretained(this)),
         kContinueWindowShowTimeoutMs));
   } else if (!start) {
@@ skipping 16 matching lines @@
 }
 
 void DesktopEnvironment::OnShutdownHostTimer() {
   DCHECK(context_->ui_message_loop()->BelongsToCurrentThread());
 
   ShowContinueWindow(false);
   host_->Shutdown(base::Closure());
 }
 
 }  // namespace remoting