Made DesktopEnvironment responsible for creation of the disconnect window.

remoting/host/disconnect_window_mac.mm

Index: remoting/host/disconnect_window_mac.mm
diff --git a/remoting/host/disconnect_window_mac.mm b/remoting/host/disconnect_window_mac.mm
index bc3015afed7c9af0cd44e10954e79c3914d23274..3121766b88eb15d4f498c8ddafaeb01a5a9c688b 100644
--- a/remoting/host/disconnect_window_mac.mm
+++ b/remoting/host/disconnect_window_mac.mm
@@ -6,10 +6,14 @@
 
 #import "remoting/host/disconnect_window_mac.h"
 
+#include "base/bind.h"
 #include "base/compiler_specific.h"
+#include "base/location.h"
+#include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
 #include "base/string_util.h"
 #include "base/strings/sys_string_conversions.h"
-#include "remoting/host/disconnect_window.h"
+#include "remoting/host/host_window.h"
 #include "remoting/host/ui_strings.h"
 
 @interface DisconnectWindowController()
@@ -17,58 +21,99 @@
 - (void)Hide;
 @end
 
+const int kMaximumConnectedNameWidthInPixels = 400;
+
 namespace remoting {
 
-class DisconnectWindowMac : public remoting::DisconnectWindow {
+class DisconnectWindowMac : public HostWindow::Core {
  public:
-  explicit DisconnectWindowMac(const UiStrings* ui_strings);
+  DisconnectWindowMac(
+      scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+      const base::Closure& disconnect_callback,
+      const std::string& username,
+      const UiStrings& ui_strings);
+
+ private:
+  friend class base::RefCountedThreadSafe<Core>;
   virtual ~DisconnectWindowMac();
 
-  virtual bool Show(const base::Closure& disconnect_callback,
-                    const std::string& username) OVERRIDE;
-  virtual void Hide() OVERRIDE;
+  // HostWindow::Core overrides.
+  virtual void StartOnUiThread() OVERRIDE;
+  virtual void StopOnUiThread() OVERRIDE;
 
- private:
-  DisconnectWindowController* window_controller_;
+  // Posts |disconnect_callback_| to the |caller_task_runner_| thread.
+  void DisconnectSession();
+
+  // Invoked in the |caller_task_runner_| thread to disconnect the client
+  // session.
+  base::Closure disconnect_callback_;
 
-  // Points to the localized strings.
-  const UiStrings* ui_strings_;
+  // Specifies the remote user name.
+  std::string username_;
+
+  DisconnectWindowController* window_controller_;
 
   DISALLOW_COPY_AND_ASSIGN(DisconnectWindowMac);
 };
 
-DisconnectWindowMac::DisconnectWindowMac(const UiStrings* ui_strings)
-    : window_controller_(nil),
-      ui_strings_(ui_strings) {
+DisconnectWindowMac::DisconnectWindowMac(
+    scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    const base::Closure& disconnect_callback,
+    const std::string& username,
+    const UiStrings& ui_strings)
+    : HostWindow::Core(caller_task_runner,
+                       ui_task_runner,
+                       ui_strings),
+      disconnect_callback_(disconnect_callback),
+      username_(username),
+      window_controller_(NULL) {
 }
 
 DisconnectWindowMac::~DisconnectWindowMac() {
-  Hide();
 }
 
-bool DisconnectWindowMac::Show(const base::Closure& disconnect_callback,
-                               const std::string& username) {
-  DCHECK(!disconnect_callback.is_null());
+void DisconnectWindowMac::StartOnUiThread() {
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
   DCHECK(window_controller_ == nil);
 
+  base::Closure disconnect_callback =
+      base::Bind(&DisconnectWindowMac::DisconnectSession, this);
   window_controller_ =
-      [[DisconnectWindowController alloc] initWithUiStrings:ui_strings_
+      [[DisconnectWindowController alloc] initWithUiStrings:&ui_strings()
                                                    callback:disconnect_callback
-                                                   username:username];
+                                                   username:username_];
   [window_controller_ showWindow:nil];
-  return true;
 }
 
-void DisconnectWindowMac::Hide() {
+void DisconnectWindowMac::StopOnUiThread() {
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
+
   // DisconnectWindowController is responsible for releasing itself in its
   // windowWillClose: method.
   [window_controller_ Hide];
   window_controller_ = nil;
 }
 
-scoped_ptr<DisconnectWindow> DisconnectWindow::Create(
-    const UiStrings* ui_strings) {
-  return scoped_ptr<DisconnectWindow>(new DisconnectWindowMac(ui_strings));
+scoped_ptr<HostWindow> HostWindow::CreateDisconnectWindow(
+    scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
+    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
+    const base::Closure& disconnect_callback,
+    const std::string& username,
+    const UiStrings& ui_strings) {
+  scoped_refptr<Core> core = new DisconnectWindowMac(caller_task_runner,
+                                                     ui_task_runner,
+                                                     disconnect_callback,
+                                                     username,
+                                                     ui_strings);
+  return scoped_ptr<HostWindow>(new HostWindow(core));
+}
+
+void DisconnectWindowMac::DisconnectSession() {
+  DCHECK(ui_task_runner()->BelongsToCurrentThread());
+
+  caller_task_runner()->PostTask(FROM_HERE, disconnect_callback_);

[Sergey Ulanov, 2013/04/02 19:04:22]

This may not be safe. disconnect_callback_ may be called after HostWindow object
is destroyed and the callback handled may not expect it. You need to post task
for DisconnectWindowMac and check that HostWindow still exists on the caller
thread before calling the callback.

[alexeypa (please no reviews), 2013/04/03 20:26:43]

This code uses a weak pointer to an interface so it should be safe.

 }
 
 }  // namespace remoting
@@ -120,10 +165,8 @@ scoped_ptr<DisconnectWindow> DisconnectWindow::Create(
   CGFloat newConnectedWidth = NSWidth(connectedToFrame);
 
   // Set a max width for the connected to text field.
-  if (newConnectedWidth >
-      remoting::DisconnectWindow::kMaximumConnectedNameWidthInPixels) {
-    newConnectedWidth
-        = remoting::DisconnectWindow::kMaximumConnectedNameWidthInPixels;
+  if (newConnectedWidth > kMaximumConnectedNameWidthInPixels) {
+    newConnectedWidth = kMaximumConnectedNameWidthInPixels;
     connectedToFrame.size.width = newConnectedWidth;
     [connectedToField_ setFrame:connectedToFrame];
   }