Made DesktopEnvironment responsible for creation of the disconnect window.

remoting/host/disconnect_window_mac.mm

 // Copyright (c) 2012 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.
 
 #import <Cocoa/Cocoa.h>
 
 #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()
 - (BOOL)isRToL;
 - (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:
+  // 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_;
+
+  // Specifies the remote user name.
+  std::string username_;
+
   DisconnectWindowController* window_controller_;
 
-  // Points to the localized strings.
-  const UiStrings* ui_strings_;
-
   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
 
 @implementation DisconnectWindowController
 - (id)initWithUiStrings:(const remoting::UiStrings*)ui_strings
                callback:(const base::Closure&)disconnect_callback
                username:(const std::string&)username {
   self = [super initWithWindowNibName:@"disconnect_window"];
   if (self) {
@@ skipping 31 matching lines @@
   [disconnectButton_ setTitle:base::SysUTF16ToNSString(
       ui_strings_->disconnect_button_text)];
 
   // Resize the window dynamically based on the content.
   CGFloat oldConnectedWidth = NSWidth([connectedToField_ bounds]);
   [connectedToField_ sizeToFit];
   NSRect connectedToFrame = [connectedToField_ frame];
   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];
   }
 
   CGFloat oldDisconnectWidth = NSWidth([disconnectButton_ bounds]);
   [disconnectButton_ sizeToFit];
   NSRect disconnectFrame = [disconnectButton_ frame];
   CGFloat newDisconnectWidth = NSWidth(disconnectFrame);
 
   // Move the disconnect button appropriately.
@@ skipping 147 matching lines @@
   path = [NSBezierPath bezierPath];
   [path moveToPoint:top];
   [path lineToPoint:bottom];
   [light setStroke];
   [path stroke];
 
   [context setShouldAntialias:alias];
 }
 
 @end