Merge remote-tracking branch 'origin/master' into fcitx

Author: Fcitx Bot

src/base/win32/BUILD.bazel

@@ -295,8 +295,9 @@ mozc_cc_library(
     tags = MOZC_TAGS.WIN_ONLY,
     target_compatible_with = ["@platforms//os:windows"],
     deps = [
+        ":hresult",
         ":hresultor",
-        "@com_google_absl//absl/meta:type_traits",
+        "@com_google_absl//absl/base:nullability",
         "@com_microsoft_wil//:wil",
     ],
 )

src/base/win32/com.h

@@ -42,6 +42,7 @@
 #include <type_traits>
 #include <utility>
 
+#include "absl/base/nullability.h"
 #include "base/win32/hresult.h"
 #include "base/win32/hresultor.h"
 
@@ -134,6 +135,71 @@ inline wil::unique_bstr MakeUniqueBSTR(const wchar_t *source) {
   return wil::unique_bstr(SysAllocString(source));
 }
 
+// Saves the value to the out parameter of a COM method.
+//
+// Return values:
+//   - S_OK: success.
+//   - E_INVALIDARG: the out parameter is null.
+//   - E_OUTOFMEMORY: the value is a null pointer.
+//
+// Note: this behavior is different from IUnknown methods. Check COM interface
+// documentation to make sure the returned error codes are correct.
+template <typename T, typename U>
+  requires std::integral<T> && std::integral<U>
+HResult SaveToOutParam(T value, U *absl_nullable out);
+template <typename T, typename U>
+HResult SaveToOutParam(T *absl_nullable value, U **absl_nullable out);
+template <typename T, typename U>
+HResult SaveToOutParam(wil::com_ptr_nothrow<T> value, U **absl_nullable out) {
+  return SaveToOutParam<T, U>(value.detach(), out);
+}
+template <typename T>
+HResult SaveToOutParam(
+    wil::unique_any_t<T> value,
+    typename wil::unique_any_t<T>::pointer *absl_nullable out) {
+  return SaveToOutParam(value.release(), out);
+}
+
+// Saves the value to the out parameter of a COM method. It's a noop if the
+// out parameter is nullptr.
+template <typename T, typename U>
+  requires std::integral<T> && std::integral<U>
+void SaveToOptionalOutParam(T value, U *absl_nullable out);
+
+// Implementations.
+
+template <typename T, typename U>
+  requires std::integral<T> && std::integral<U>
+HResult SaveToOutParam(T value, U *absl_nullable out) {
+  static_assert(std::convertible_to<T, U>);
+  if (out == nullptr) {
+    return HResultInvalidArg();
+  }
+  *out = value;
+  return HResultOk();
+}
+
+template <typename T, typename U>
+HResult SaveToOutParam(T *absl_nullable value, U **absl_nullable out) {
+  if (out == nullptr) {
+    return HResultInvalidArg();
+  }
+  if (value == nullptr) {
+    return HResultOutOfMemory();
+  }
+  *out = value;
+  return HResultOk();
+}
+
+template <typename T, typename U>
+  requires std::integral<T> && std::integral<U>
+void SaveToOptionalOutParam(T value, U *absl_nullable out) {
+  static_assert(std::convertible_to<T, U>);
+  if (out != nullptr) {
+    *out = value;
+  }
+}
+
 }  // namespace mozc::win32
 
 #endif  // MOZC_BASE_WIN32_COM_H_

src/base/win32/com_test.cc

@@ -48,6 +48,8 @@
 namespace mozc::win32 {
 namespace {
 
+using ::testing::IsNull;
+using ::testing::NotNull;
 using ::testing::StrEq;
 
 // Mock interfaces for testing.
@@ -113,38 +115,38 @@ class ComTest : public ::testing::Test {
 TEST_F(ComTest, ComCreateInstance) {
   wil::com_ptr_nothrow<IShellLink> shellink =
       ComCreateInstance<IShellLink, ShellLink>();
-  EXPECT_TRUE(shellink);
-  EXPECT_TRUE(ComCreateInstance<IShellLink>(CLSID_ShellLink));
-  EXPECT_FALSE(ComCreateInstance<IShellFolder>(CLSID_ShellLink));
+  EXPECT_THAT(shellink, NotNull());
+  EXPECT_THAT(ComCreateInstance<IShellLink>(CLSID_ShellLink), NotNull());
+  EXPECT_THAT(ComCreateInstance<IShellFolder>(CLSID_ShellLink), IsNull());
 }
 
 TEST_F(ComTest, MakeComPtr) {
   auto ptr = MakeComPtr<Mock>();
-  EXPECT_TRUE(ptr);
+  ASSERT_THAT(ptr, NotNull());
   EXPECT_EQ(object_count, 1);
   EXPECT_EQ(ptr->GetQICountAndReset(), 0);
 }
 
 TEST_F(ComTest, ComQuery) {
   wil::com_ptr_nothrow<IMock1> mock1(MakeComPtr<Mock>());
-  EXPECT_TRUE(mock1);
+  ASSERT_THAT(mock1, NotNull());
   EXPECT_EQ(mock1->Test1(), S_OK);
 
   wil::com_ptr_nothrow<IDerived> derived = ComQuery<IDerived>(mock1);
-  EXPECT_TRUE(derived);
+  ASSERT_THAT(derived, NotNull());
   EXPECT_EQ(derived->Derived(), 2);
   EXPECT_EQ(derived->GetQICountAndReset(), 1);
 
-  EXPECT_TRUE(ComQuery<IMock1>(derived));
+  EXPECT_THAT(ComQuery<IMock1>(derived), NotNull());
   EXPECT_EQ(derived->GetQICountAndReset(), 0);
 
   wil::com_ptr_nothrow<IMock2> mock2 = ComQuery<IMock2>(mock1);
-  EXPECT_TRUE(mock2);
+  ASSERT_THAT(mock2, NotNull());
   EXPECT_EQ(mock2->Test2(), S_FALSE);
   EXPECT_EQ(mock1->GetQICountAndReset(), 1);
 
   mock2 = ComQuery<IMock2>(mock1);
-  EXPECT_TRUE(mock2);
+  ASSERT_THAT(mock2, NotNull());
   EXPECT_EQ(mock2->Test2(), S_FALSE);
   EXPECT_EQ(mock1->GetQICountAndReset(), 1);
 
@@ -154,18 +156,18 @@ TEST_F(ComTest, ComQuery) {
 
 TEST_F(ComTest, ComCopy) {
   wil::com_ptr_nothrow<IMock1> mock1(MakeComPtr<Mock>());
-  EXPECT_TRUE(mock1);
+  ASSERT_THAT(mock1, NotNull());
   EXPECT_EQ(mock1->Test1(), S_OK);
 
   wil::com_ptr_nothrow<IUnknown> unknown = ComCopy<IUnknown>(mock1);
-  EXPECT_TRUE(unknown);
+  EXPECT_THAT(unknown, NotNull());
   EXPECT_EQ(mock1->GetQICountAndReset(), 0);
 
-  EXPECT_FALSE(ComCopy<IShellLink>(unknown));
+  EXPECT_THAT(ComCopy<IShellLink>(unknown), IsNull());
   EXPECT_EQ(mock1->GetQICountAndReset(), 1);
 
   IUnknown *null = nullptr;
-  EXPECT_FALSE(ComCopy<IUnknown>(null));
+  EXPECT_THAT(ComCopy<IUnknown>(null), IsNull());
 }
 
 TEST(ComBSTRTest, MakeUniqueBSTR) {
@@ -177,5 +179,50 @@ TEST(ComBSTRTest, MakeUniqueBSTR) {
   EXPECT_EQ(result.get(), kSource);
 }
 
+TEST(SaveToOutParam, Nullptr) {
+  EXPECT_EQ(SaveToOutParam(0, static_cast<int *>(nullptr)), E_INVALIDARG);
+  EXPECT_EQ(SaveToOutParam(wil::unique_bstr(), static_cast<BSTR *>(nullptr)),
+            E_INVALIDARG);
+  EXPECT_EQ(
+      SaveToOutParam(static_cast<BSTR>(nullptr), static_cast<BSTR *>(nullptr)),
+      E_INVALIDARG);
+  EXPECT_EQ(SaveToOutParam(wil::com_ptr_nothrow<IMock1>(),
+                           static_cast<IMock1 **>(nullptr)),
+            E_INVALIDARG);
+}
+
+TEST(SaveToOutParam, OutOfMemory) {
+  BSTR out = nullptr;
+  EXPECT_EQ(SaveToOutParam(static_cast<BSTR>(nullptr), &out), E_OUTOFMEMORY);
+}
+
+TEST(SaveToOutParam, BSTR) {
+  wil::unique_bstr output;
+  EXPECT_EQ(SaveToOutParam(MakeUniqueBSTR(L"Hello"), output.put()), S_OK);
+  EXPECT_THAT(output.get(), StrEq(L"Hello"));
+}
+
+TEST(SaveToOutParam, ComPtr) {
+  wil::com_ptr_nothrow<IMock1> output;
+  EXPECT_EQ(SaveToOutParam(MakeComPtr<Mock>(), output.put()), S_OK);
+  EXPECT_THAT(output, NotNull());
+}
+
+TEST(SaveToOutParam, Int) {
+  int output = 1;
+  EXPECT_EQ(SaveToOutParam(0, &output), S_OK);
+  EXPECT_EQ(output, 0);
+}
+
+TEST(SaveToOptionalOutParam, Nullptr) {
+  SaveToOptionalOutParam(1, static_cast<int *>(nullptr));
+}
+
+TEST(SaveToOptionalOutParam, Int) {
+  int output = 1;
+  SaveToOptionalOutParam(0, &output);
+  EXPECT_EQ(output, 0);
+}
+
 }  // namespace
 }  // namespace mozc::win32

src/converter/candidate.h

@@ -66,7 +66,7 @@ class Candidate {
   // Allows to refer Attribute via Candidate::XXX
   // TODO(taku): Remove this alias after full migration.
   using Attribute = converter::Attribute::Attribute_;
-  using enum Attribute;
+  using enum converter::Attribute::Attribute_;
 
   enum Command {
     DEFAULT_COMMAND = 0,

src/converter/inner_segment.h

@@ -310,6 +310,33 @@ class InnerSegments {
     return std::make_pair(key, value);
   }
 
+  // Returns the concatenated suffix key and value of segments size `size`, used
+  // in history result. When size is -1, returns all key/value.
+  std::pair<absl::string_view, absl::string_view> GetSuffixKeyAndValue(
+      int size = -1) const {
+    absl::string_view key = begin_.data_.key_;
+    absl::string_view value = begin_.data_.value_;
+
+    if (size == 0) {
+      // Returns last empty string so to allow pointer diff.
+      return std::make_pair(key.substr(key.size()), value.substr(value.size()));
+    }
+
+    int index = this->size() - size - 1;
+
+    if (size < 0 || index < 0) {
+      return std::make_pair(key, value);
+    } else {
+      for (const auto& iter : *this) {
+        key.remove_prefix(iter.GetKey().size());
+        value.remove_prefix(iter.GetValue().size());
+        if (index-- == 0) return std::make_pair(key, value);
+      }
+    }
+
+    return std::make_pair(key, value);
+  }
+
   // Constructor for the structure only with key/value.
   InnerSegments(absl::string_view key, absl::string_view value,
                 InnerSegmentBoundarySpan inner_segment_boundary)

src/converter/inner_segment_test.cc

@@ -34,6 +34,7 @@
 #include <vector>
 
 #include "absl/log/log.h"
+#include "absl/strings/str_cat.h"
 #include "absl/strings/string_view.h"
 #include "testing/gunit.h"
 
@@ -241,5 +242,94 @@ TEST(InnerSegment, InnerSegmentIteratorInvalid) {
   }
 }
 
+TEST(InnerSegments, GetSuffixKeyAndValue) {
+  auto suffix_key_default = [](const InnerSegments &inner_segments) {
+    return inner_segments.GetSuffixKeyAndValue().first;
+  };
+
+  auto suffix_value_default = [](const InnerSegments &inner_segments) {
+    return inner_segments.GetSuffixKeyAndValue().second;
+  };
+
+  auto suffix_key = [](const InnerSegments &inner_segments, int size) {
+    return inner_segments.GetSuffixKeyAndValue(size).first;
+  };
+
+  auto suffix_value = [](const InnerSegments &inner_segments, int size) {
+    return inner_segments.GetSuffixKeyAndValue(size).second;
+  };
+
+  {
+    std::string all_key, all_value;
+
+    converter::InnerSegmentBoundaryBuilder builder;
+
+    auto add_segment = [&](absl::string_view key, absl::string_view value) {
+      builder.Add(key.size(), value.size(), key.size(), value.size());
+      absl::StrAppend(&all_key, key);
+      absl::StrAppend(&all_value, value);
+    };
+
+    for (int i = 0; i < 3; ++i) {
+      add_segment(absl::StrCat("k", i), absl::StrCat("v", i));
+    }
+
+    InnerSegmentBoundary inner_segment_boundary =
+        builder.Build(all_key, all_value);
+
+    const InnerSegments inner_segments(all_key, all_value,
+                                       inner_segment_boundary);
+
+    EXPECT_EQ(inner_segments.size(), 3);
+    EXPECT_EQ(suffix_key_default(inner_segments), "k0k1k2");
+    EXPECT_EQ(suffix_value_default(inner_segments), "v0v1v2");
+    EXPECT_EQ(suffix_key(inner_segments, -1), "k0k1k2");
+    EXPECT_EQ(suffix_value(inner_segments, -1), "v0v1v2");
+    EXPECT_EQ(suffix_key(inner_segments, 10), "k0k1k2");
+    EXPECT_EQ(suffix_value(inner_segments, 10), "v0v1v2");
+    EXPECT_EQ(suffix_key(inner_segments, 0), "");
+    EXPECT_EQ(suffix_value(inner_segments, 0), "");
+    EXPECT_EQ(suffix_key(inner_segments, 1), "k2");
+    EXPECT_EQ(suffix_value(inner_segments, 1), "v2");
+    EXPECT_EQ(suffix_key(inner_segments, 2), "k1k2");
+    EXPECT_EQ(suffix_value(inner_segments, 2), "v1v2");
+    EXPECT_EQ(suffix_key(inner_segments, 3), "k0k1k2");
+    EXPECT_EQ(suffix_value(inner_segments, 3), "v0v1v2");
+    EXPECT_EQ(suffix_key(inner_segments, 4), "k0k1k2");
+    EXPECT_EQ(suffix_value(inner_segments, 4), "v0v1v2");
+  }
+
+  {
+    const InnerSegments inner_segments("", "", {});
+
+    EXPECT_EQ(inner_segments.size(), 0);
+    EXPECT_EQ(suffix_key_default(inner_segments), "");
+    EXPECT_EQ(suffix_value_default(inner_segments), "");
+    EXPECT_EQ(suffix_key(inner_segments, -1), "");
+    EXPECT_EQ(suffix_value(inner_segments, -1), "");
+    EXPECT_EQ(suffix_key(inner_segments, 10), "");
+    EXPECT_EQ(suffix_value(inner_segments, 10), "");
+    EXPECT_EQ(suffix_key(inner_segments, 0), "");
+    EXPECT_EQ(suffix_value(inner_segments, 0), "");
+    EXPECT_EQ(suffix_key(inner_segments, 2), "");
+    EXPECT_EQ(suffix_value(inner_segments, 2), "");
+    EXPECT_EQ(suffix_key(inner_segments, 1), "");
+    EXPECT_EQ(suffix_value(inner_segments, 1), "");
+  }
+
+  {
+    const InnerSegments inner_segments("key", "value", {});
+    EXPECT_EQ(inner_segments.size(), 1);
+    EXPECT_EQ(suffix_key_default(inner_segments), "key");
+    EXPECT_EQ(suffix_value_default(inner_segments), "value");
+    EXPECT_EQ(suffix_key(inner_segments, -1), "key");
+    EXPECT_EQ(suffix_value(inner_segments, -1), "value");
+    EXPECT_EQ(suffix_key(inner_segments, 1), "key");
+    EXPECT_EQ(suffix_value(inner_segments, 1), "value");
+    EXPECT_EQ(suffix_key(inner_segments, 2), "key");
+    EXPECT_EQ(suffix_value(inner_segments, 2), "value");
+  }
+}
+
 }  // namespace converter
 }  // namespace mozc