Wires up modality for aura-mus

ui/aura/mus/window_tree_client.cc

 // Copyright 2014 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/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 13 matching lines @@
 #include "ui/aura/mus/surface_id_handler.h"
 #include "ui/aura/mus/window_manager_delegate.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_port_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_tracker.h"
+#include "ui/base/ui_base_types.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size.h"
 
 #if defined(HiWord)
 #undef HiWord
 #endif
 #if defined(LoWord)
 #undef LoWord
 #endif
@@ skipping 64 matching lines @@
     }
   }
 
  private:
   std::unique_ptr<EventResultCallback> ack_callback_;
   bool handled_ = false;
 
   DISALLOW_COPY_AND_ASSIGN(EventAckHandler);
 };
 
+bool IsInternalProperty(const void* key) {
+  return key == client::kModalKey;
+}
+
 }  // namespace
 
 struct WindowTreeClient::CurrentDragState {
   // The current change id of the current drag an drop ipc.
   uint32_t change_id;
 
   // The effect to return when we send our finish signal.
   uint32_t completed_action;
 
   // Callback executed when a drag initiated by PerformDragDrop() is completed.
@@ skipping 363 matching lines @@
   if (window_manager_delegate_) {
     tree_ptr_->GetWindowManagerClient(GetProxy(&window_manager_internal_client_,
                                                tree_ptr_.associated_group()));
   }
 }
 
 void WindowTreeClient::OnConnectionLost() {
   delegate_->OnLostConnection(this);
 }
 
+bool WindowTreeClient::HandleInternalPropertyChanged(WindowMus* window,
+                                                     const void* key) {
+  if (key != client::kModalKey)

[msw, 2016/10/27 18:37:37]

q: check !IsInternalProperty(key) for extensibility, then put the other code in
a if (key == client::kModalKey) check? Feel free to ignore for now and just
address this when we add other internal properties.

[sky, 2016/10/27 19:30:06]

Ya, I figured once we have more than one property we'll do that.

+    return false;
+
+  if (window->GetWindow()->GetProperty(client::kModalKey) ==
+      ui::MODAL_TYPE_NONE) {
+    return true;

[msw, 2016/10/27 18:37:37]

Should this be clearing modality if the window was previously modal?

[sky, 2016/10/27 19:30:06]

Yes, but again because the mojom API is basically only turn on, it can't work.
Added TODO.

+  }
+
+  const uint32_t change_id =
+      ScheduleInFlightChange(base::MakeUnique<InFlightSetModalChange>(window));
+  // TODO: this is subtly different that explicitly specifying a type.
+  // http://crbug.com/660073.
+  tree_->SetModal(change_id, window->server_id());
+  return true;
+}
+
 void WindowTreeClient::OnEmbedImpl(ui::mojom::WindowTree* window_tree,
                                    ClientSpecificId client_id,
                                    ui::mojom::WindowDataPtr root_data,
                                    int64_t display_id,
                                    Id focused_window_id,
                                    bool drawn) {
   // WARNING: this is only called if WindowTreeClient was created as the
   // result of an embedding.
   tree_ = window_tree;
   client_id_ = client_id;
@@ skipping 186 matching lines @@
   // TODO: add checks to ensure this can work.
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
       base::MakeUnique<InFlightVisibleChange>(window, !visible));
   tree_->SetWindowVisibility(change_id, window->server_id(), visible);
 }
 
 std::unique_ptr<WindowPortPropertyData>
 WindowTreeClient::OnWindowMusWillChangeProperty(WindowMus* window,
                                                 const void* key) {
+  if (IsInternalProperty(key))
+    return nullptr;
+
   std::unique_ptr<WindowPortPropertyDataMus> data(
       base::MakeUnique<WindowPortPropertyDataMus>());
   if (!delegate_->GetPropertyConverter()->ConvertPropertyForTransport(
           window->GetWindow(), key, &data->transport_name,
           &data->transport_value)) {
     return nullptr;
   }
   return std::move(data);
 }
 
 void WindowTreeClient::OnWindowMusPropertyChanged(
     WindowMus* window,
     const void* key,
     std::unique_ptr<WindowPortPropertyData> data) {
+  if (HandleInternalPropertyChanged(window, key))

[msw, 2016/10/27 18:37:37]

optional nit: combine with the !data early return below.

[sky, 2016/10/27 19:30:06]

Done.

+    return;
+
   if (!data)
     return;
+
   WindowPortPropertyDataMus* data_mus =
       static_cast<WindowPortPropertyDataMus*>(data.get());
 
   std::string transport_name;
   std::unique_ptr<std::vector<uint8_t>> transport_value;
   if (!delegate_->GetPropertyConverter()->ConvertPropertyForTransport(
           window->GetWindow(), key, &transport_name, &transport_value)) {
     return;
   }
   DCHECK_EQ(transport_name, data_mus->transport_name);
@@ skipping 918 matching lines @@
       base::MakeUnique<InFlightCaptureChange>(this, capture_window_));
   WindowMus* old_capture_window = capture_window_;
   capture_window_ = gained_capture_mus;
   if (capture_window_)
     tree_->SetCapture(change_id, capture_window_->server_id());
   else
     tree_->ReleaseCapture(change_id, old_capture_window->server_id());
 }
 
 }  // namespace aura