Refactor candidate string classes

- Moved class definitions to header files for readability.
- Moved each class to separate files and added unit tests.
- Added SaveToOutParam and SaveToOptionalOutParam functions to com.h to reduce boilerplate.

#codehealth

PiperOrigin-RevId: 791964304

Author: yuryu

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/win32/tip/BUILD.bazel

@@ -219,8 +219,6 @@ mozc_cc_library(
         ":tip_thread_context",
         ":tip_ui_handler",
         "//base:const",
-        "//base:file_util",
-        "//base:log_file",
         "//base:process",
         "//base:system_util",
         "//base:update_util",
@@ -270,15 +268,74 @@ mozc_cc_library(
     ],
 )
 
+mozc_cc_library(
+    name = "tip_candidate_string",
+    srcs = ["tip_candidate_string.cc"],
+    hdrs = ["tip_candidate_string.h"],
+    tags = MOZC_TAGS.WIN_ONLY,
+    target_compatible_with = ["@platforms//os:windows"],
+    deps = [
+        ":tip_dll_module",
+        "//base/win32:com",
+        "@com_google_absl//absl/base:nullability",
+    ],
+)
+
+mozc_cc_test(
+    name = "tip_candidate_string_test",
+    size = "small",
+    srcs = ["tip_candidate_string_test.cc"],
+    tags = MOZC_TAGS.WIN_ONLY,
+    target_compatible_with = ["@platforms//os:windows"],
+    deps = [
+        ":gmock_matchers",
+        ":tip_candidate_string",
+        "//testing:gunit_main",
+        "@com_microsoft_wil//:wil",
+    ],
+)
+
+mozc_cc_library(
+    name = "tip_enum_candidates",
+    srcs = ["tip_enum_candidates.cc"],
+    hdrs = ["tip_enum_candidates.h"],
+    tags = MOZC_TAGS.WIN_ONLY,
+    target_compatible_with = ["@platforms//os:windows"],
+    deps = [
+        ":tip_candidate_string",
+        ":tip_dll_module",
+        "//base/win32:com",
+        "@com_google_absl//absl/base:nullability",
+    ],
+)
+
+mozc_cc_test(
+    name = "tip_enum_candidates_test",
+    size = "small",
+    srcs = ["tip_enum_candidates_test.cc"],
+    tags = MOZC_TAGS.WIN_ONLY,
+    target_compatible_with = ["@platforms//os:windows"],
+    deps = [
+        ":gmock_matchers",
+        ":tip_enum_candidates",
+        "//testing:gunit_main",
+        "@com_microsoft_wil//:wil",
+    ],
+)
+
 mozc_cc_library(
     name = "tip_candidate_list",
     srcs = ["tip_candidate_list.cc"],
     hdrs = ["tip_candidate_list.h"],
     tags = MOZC_TAGS.WIN_ONLY,
     target_compatible_with = ["@platforms//os:windows"],
     deps = [
+        ":tip_candidate_string",
         ":tip_dll_module",
+        ":tip_enum_candidates",
         "//base/win32:com",
+        "@com_google_absl//absl/base:nullability",
+        "@com_google_absl//absl/functional:any_invocable",
         "@com_microsoft_wil//:wil",
     ],
 )
@@ -409,6 +466,7 @@ mozc_cc_library(
         ":tip_query_provider",
         "//base/win32:com",
         "//base/win32:com_implements",
+        "@com_google_absl//absl/base:nullability",
         "@com_microsoft_wil//:wil",
     ],
 )
@@ -565,6 +623,7 @@ mozc_cc_library(
         ":tip_text_service",
         "//base/win32:com",
         "//base/win32:com_implements",
+        "@com_google_absl//absl/base:nullability",
         "@com_microsoft_wil//:wil",
     ],
 )
@@ -640,6 +699,7 @@ mozc_cc_library(
         ":tip_text_service",
         "//base/win32:com",
         "//base/win32:com_implements",
+        "@com_google_absl//absl/base:nullability",
         "@com_microsoft_wil//:wil",
     ],
 )
@@ -755,9 +815,11 @@ mozc_cc_test(
     tags = MOZC_TAGS.WIN_ONLY,
     target_compatible_with = ["@platforms//os:windows"],
     deps = [
+        ":gmock_matchers",
         ":tip_candidate_list",
-        ":tip_dll_module",
+        "//base/win32:com",
         "//testing:gunit_main",
+        "@com_google_absl//absl/base:core_headers",
         "@com_google_absl//absl/strings",
         "@com_microsoft_wil//:wil",
     ],
@@ -800,3 +862,17 @@ mozc_cc_test(
         "//testing:gunit_main",
     ],
 )
+
+mozc_cc_library(
+    name = "gmock_matchers",
+    testonly = True,
+    hdrs = ["gmock_matchers.h"],
+    tags = MOZC_TAGS.WIN_ONLY,
+    target_compatible_with = ["@platforms//os:windows"],
+    deps = [
+        "//base/win32:hresult",
+        "//base/win32:wide_char",
+        "//testing:gunit",
+        "@com_microsoft_wil//:wil",
+    ],
+)