Make WindowTree::SetModal() take the type.

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 465 matching lines @@
   drag_drop_controller_ = base::MakeUnique<DragDropControllerMus>(this, tree_);
   capture_synchronizer_ = base::MakeUnique<CaptureSynchronizer>(this, tree_);
   focus_synchronizer_ = base::MakeUnique<FocusSynchronizer>(this, tree_);
 }
 
 void WindowTreeClient::OnConnectionLost() {
   delegate_->OnLostConnection(this);
 }
 
 bool WindowTreeClient::HandleInternalPropertyChanged(WindowMus* window,
-                                                     const void* key) {
+                                                     const void* key,
+                                                     int64_t old_value) {
   if (key != client::kModalKey)
     return false;
 
-  if (window->GetWindow()->GetProperty(client::kModalKey) ==
-      ui::MODAL_TYPE_NONE) {
-    // TODO: shouldn't early return, but explicitly tell server to turn off
-    // modality. http://crbug.com/660073.
-    return true;
-  }
-
   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());
+      ScheduleInFlightChange(base::MakeUnique<InFlightSetModalTypeChange>(
+          window, static_cast<ui::ModalType>(old_value)));
+  tree_->SetModalType(change_id, window->server_id(),
+                      window->GetWindow()->GetProperty(client::kModalKey));
   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
@@ skipping 218 matching lines @@
           window->GetWindow(), key, &data->transport_name,
           &data->transport_value)) {
     return nullptr;
   }
   return std::move(data);
 }
 
 void WindowTreeClient::OnWindowMusPropertyChanged(
     WindowMus* window,
     const void* key,
+    int64_t old_value,
     std::unique_ptr<ui::PropertyData> data) {
-  if (HandleInternalPropertyChanged(window, key) || !data)
+  if (HandleInternalPropertyChanged(window, key, old_value) || !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;
@@ skipping 1072 matching lines @@
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
 }  // namespace aura