Fix releasing capture in Ozone

ui/wm/core/capture_controller.cc

 // 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.
 
 #include "ui/wm/core/capture_controller.h"
 
 #include "ui/aura/window.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/aura/window_tree_host.h"
 
@@ skipping 18 matching lines @@
 
 void CaptureController::SetCapture(aura::Window* new_capture_window) {
   if (capture_window_ == new_capture_window)
     return;
 
   // Make sure window has a root window.
   DCHECK(!new_capture_window || new_capture_window->GetRootWindow());
   DCHECK(!capture_window_ || capture_window_->GetRootWindow());
 
   aura::Window* old_capture_window = capture_window_;
-  aura::Window* old_capture_root = old_capture_window ?
-      old_capture_window->GetRootWindow() : NULL;
+  aura::client::CaptureDelegate* old_capture_delegate = capture_delegate_;
 
   // Copy the list in case it's modified out from under us.
   RootWindows root_windows(root_windows_);
 
   // If we're actually starting capture, then cancel any touches/gestures
   // that aren't already locked to the new window, and transfer any on the
   // old capture window to the new one.  When capture is released we have no
   // distinction between the touches/gestures that were in the window all
   // along (and so shouldn't be canceled) and those that got moved, so
   // just leave them all where they are.
   if (new_capture_window) {
     ui::GestureRecognizer::Get()->TransferEventsTo(old_capture_window,
         new_capture_window);
   }
 
   capture_window_ = new_capture_window;
+  aura::Window* capture_root_window =
+      capture_window_ ? capture_window_->GetRootWindow() : NULL;

[sadrul, 2014/12/11 15:11:00]

nullptr

+  capture_delegate_ = capture_root_window

[sadrul, 2014/12/11 15:11:00]

Can |capture_delegate| be a local variable instead?

+      ? capture_root_window->GetHost()->dispatcher()
+      : NULL;
 
   for (RootWindows::const_iterator i = root_windows.begin();
        i != root_windows.end(); ++i) {
     aura::client::CaptureDelegate* delegate = (*i)->GetHost()->dispatcher();
     delegate->UpdateCapture(old_capture_window, new_capture_window);
   }
 
-  aura::Window* capture_root =
-      capture_window_ ? capture_window_->GetRootWindow() : NULL;
-  if (capture_root != old_capture_root) {
-    if (old_capture_root) {
-      aura::client::CaptureDelegate* delegate =
-          old_capture_root->GetHost()->dispatcher();
-      delegate->ReleaseNativeCapture();
-    }
-    if (capture_root) {
-      aura::client::CaptureDelegate* delegate =
-          capture_root->GetHost()->dispatcher();
-      delegate->SetNativeCapture();
-    }
+  if (capture_delegate_ != old_capture_delegate) {
+    if (old_capture_delegate)
+      old_capture_delegate->ReleaseNativeCapture();
+    if (capture_delegate_)
+      capture_delegate_->SetNativeCapture();

[sadrul, 2014/12/11 15:11:00]

The old code makes much more sense when reading than the new code. Can you
explain how this is different from the old code?

[pkotwicz, 2014/12/11 16:22:49]

If a window with capture is reparented to a different WindowTreeHost, native
capture is NOT set on the new WindowTreeHost (or released from the old
WindowTreeHost)

When capture is released, native capture should be released from the
WindowTreeHost with capture
The old code assumed that "the WindowTreeHost with capture" is the same as the
WindowTreeHost containing |capture_window_|

In the email that I sent out on Sunday, I described why setting native capture
in WindowTreeHostOzone is unnecessary. However, we cannot remove the calls for
setting native capture here because of Windows Ash (which has bugs because it
does not set native capture)

   }
 }
 
 void CaptureController::ReleaseCapture(aura::Window* window) {
   if (capture_window_ != window)
     return;
   SetCapture(NULL);
 }
 
 aura::Window* CaptureController::GetCaptureWindow() {
   return capture_window_;
 }
 
 aura::Window* CaptureController::GetGlobalCaptureWindow() {
   return capture_window_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // CaptureController, private:
 
 CaptureController::CaptureController()
-    : capture_window_(NULL) {
+    : capture_window_(NULL),
+      capture_delegate_(NULL) {
 }
 
 CaptureController::~CaptureController() {
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ScopedCaptureClient:
 
 // static
 CaptureController* ScopedCaptureClient::capture_controller_ = NULL;
@@ skipping 27 matching lines @@
   root_window_->RemoveObserver(this);
   capture_controller_->Detach(root_window_);
   if (!capture_controller_->is_active()) {
     delete capture_controller_;
     capture_controller_ = NULL;
   }
   root_window_ = NULL;
 }
 
 }  // namespace wm