Implement aura::PropertyConverter for mus interop.

ui/aura/mus/window_tree_client_unittest.cc

 // Copyright 2015 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 <stdint.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "mojo/common/common_type_converters.h"
+#include "services/ui/public/cpp/property_type_converters.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/capture_client_observer.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
@@ skipping 31 matching lines @@
 }
 
 Window* GetFirstRoot(WindowTreeClient* client) {
   return client->GetRoots().empty() ? nullptr : *client->GetRoots().begin();
 }
 
 bool IsWindowHostVisible(Window* window) {
   return window->GetRootWindow()->GetHost()->compositor()->IsVisible();
 }
 
-const char kAlwaysOnTopServerKey[] = "always-on-top-server";
 const char kTestPropertyServerKey1[] = "test-property-server1";
 const char kTestPropertyServerKey2[] = "test-property-server2";
 
 class TestPropertyConverter : public PropertyConverter {
  public:
   TestPropertyConverter() {}
   ~TestPropertyConverter() override {}
 
   // PropertyConverter:
   bool ConvertPropertyForTransport(
       Window* window,
       const void* key,
       std::string* server_property_name,
       std::unique_ptr<std::vector<uint8_t>>* server_property_value) override {
-    if (key == client::kAlwaysOnTopKey) {
-      *server_property_name = kAlwaysOnTopServerKey;
-      *server_property_value = base::MakeUnique<std::vector<uint8_t>>(1);
-      (*server_property_value->get())[0] =
-          window->GetProperty(client::kAlwaysOnTopKey);
-      return true;
-    }
     if (key == kTestPropertyKey1) {
       *server_property_name = kTestPropertyServerKey1;
       *server_property_value = base::MakeUnique<std::vector<uint8_t>>(1);
       (*server_property_value->get())[0] =
           window->GetProperty(kTestPropertyKey1);
       return true;
     }
     if (key == kTestPropertyKey2) {
       *server_property_name = kTestPropertyServerKey2;
       *server_property_value = base::MakeUnique<std::vector<uint8_t>>(1);
       (*server_property_value->get())[0] =
           window->GetProperty(kTestPropertyKey2);
       return true;
     }
-    return false;
+    return PropertyConverter::ConvertPropertyForTransport(
+        window, key, server_property_name, server_property_value);
   }
 
   std::string GetTransportNameForPropertyKey(const void* key) override {
-    if (key == client::kAlwaysOnTopKey)
-      return kAlwaysOnTopServerKey;
     if (key == kTestPropertyKey1)
       return kTestPropertyServerKey1;
     if (key == kTestPropertyKey2)
       return kTestPropertyServerKey2;
-    return std::string();
+    return PropertyConverter::GetTransportNameForPropertyKey(key);
   }
 
   void SetPropertyFromTransportValue(
       Window* window,
       const std::string& server_property_name,
       const std::vector<uint8_t>* data) override {
-    if (server_property_name == kAlwaysOnTopServerKey) {
-      window->SetProperty(client::kAlwaysOnTopKey,
-                          static_cast<bool>((*data)[0]));
-    } else if (server_property_name == kTestPropertyServerKey1) {
+    if (server_property_name == kTestPropertyServerKey1) {
       window->SetProperty(kTestPropertyKey1, (*data)[0]);
     } else if (server_property_name == kTestPropertyServerKey2) {
       window->SetProperty(kTestPropertyKey2, (*data)[0]);
+    } else {
+      PropertyConverter::SetPropertyFromTransportValue(
+          window, server_property_name, data);
     }
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestPropertyConverter);
 };
 
 }  // namespace
 
 mojo::Array<uint8_t> Uint8ToPropertyTransportValue(uint8_t value) {
@@ skipping 167 matching lines @@
       window_tree()->AckFirstChangeOfType(WindowTreeChangeType::BOUNDS, false));
   EXPECT_EQ(bounds2, root_window()->bounds());
 
   // Tell the client the seconds bounds failed. Should now fallback to original
   // value.
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(WindowTreeChangeType::BOUNDS,
                                                    false));
   EXPECT_EQ(original_bounds, root_window()->bounds());
 }
 
+// Verifies properties are set if the server replied that the change succeeded.
+TEST_F(WindowTreeClientWmTest, SetPropertySucceeded) {
+  ASSERT_FALSE(root_window()->GetProperty(client::kAlwaysOnTopKey));
+  root_window()->SetProperty(client::kAlwaysOnTopKey, true);
+  EXPECT_TRUE(root_window()->GetProperty(client::kAlwaysOnTopKey));
+  mojo::Array<uint8_t> value = window_tree()->GetLastPropertyValue();
+  ASSERT_FALSE(value.is_null());
+  // PropertyConverter uses int64_t values, even for smaller types, like bool.
+  ASSERT_EQ(8u, value.size());
+  std::vector<uint8_t> array = mojo::ConvertTo<std::vector<uint8_t>>(value);
+  EXPECT_EQ(1, mojo::ConvertTo<int64_t>(array));
+  ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
+      WindowTreeChangeType::PROPERTY, true));
+  EXPECT_TRUE(root_window()->GetProperty(client::kAlwaysOnTopKey));
+}
+
 // Verifies properties are reverted if the server replied that the change
 // failed.
 TEST_F(WindowTreeClientWmTest, SetPropertyFailed) {
-  SetPropertyConverter(base::MakeUnique<TestPropertyConverter>());
   ASSERT_FALSE(root_window()->GetProperty(client::kAlwaysOnTopKey));
   root_window()->SetProperty(client::kAlwaysOnTopKey, true);
   EXPECT_TRUE(root_window()->GetProperty(client::kAlwaysOnTopKey));
-  mojo::Array<uint8_t> transport_value = window_tree()->GetLastPropertyValue();
-  ASSERT_FALSE(transport_value.is_null());
-  ASSERT_EQ(1u, transport_value.size());
-  EXPECT_EQ(1, transport_value[0]);
+  mojo::Array<uint8_t> value = window_tree()->GetLastPropertyValue();
+  ASSERT_FALSE(value.is_null());
+  // PropertyConverter uses int64_t values, even for smaller types, like bool.
+  ASSERT_EQ(8u, value.size());
+  std::vector<uint8_t> array = mojo::ConvertTo<std::vector<uint8_t>>(value);
+  EXPECT_EQ(1, mojo::ConvertTo<int64_t>(array));
   ASSERT_TRUE(window_tree()->AckSingleChangeOfType(
       WindowTreeChangeType::PROPERTY, false));
   EXPECT_FALSE(root_window()->GetProperty(client::kAlwaysOnTopKey));
 }
 
 // Simulates a property change, and while the property change is in flight the
 // server replies with a new property and the original property change fails.
 TEST_F(WindowTreeClientWmTest, SetPropertyFailedWithPendingChange) {
   SetPropertyConverter(base::MakeUnique<TestPropertyConverter>());
   const uint8_t value1 = 11;
@@ skipping 819 matching lines @@
   ASSERT_EQ(1u, root_window()->children().size());
   Window* server_window = root_window()->children()[0];
   EXPECT_EQ(window1->parent(), server_window);
   EXPECT_EQ(window2->parent(), server_window);
   ASSERT_EQ(2u, server_window->children().size());
   EXPECT_EQ(window1, server_window->children()[0]);
   EXPECT_EQ(window2, server_window->children()[1]);
 }
 
 }  // namespace aura