Remove function casting from Libsecret tests

components/os_crypt/key_storage_libsecret_unittest.cc

 // Copyright 2016 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 <string>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "components/os_crypt/key_storage_libsecret.h"
 #include "components/os_crypt/libsecret_util_linux.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
-// Mock functions use MockSecretValue, where SecretValue would appear, and are
-// cast to the correct signature. We can reduce SecretValue to an std::string,
-// because we don't use anything else from it.
+// Mock functions expect MockSecretValue, where SecretValue appears, and cast it
+// to the mock type. We can reduce SecretValue to an std::string, because we
+// don't use anything else from it.
 using MockSecretValue = std::string;
 // Likewise, we only need a SecretValue from SecretItem.
 using MockSecretItem = MockSecretValue;
 
 const SecretSchema kKeystoreSchemaV1 = {
     "chrome_libsecret_os_crypt_password",
     SECRET_SCHEMA_NONE,
     {
         {nullptr, SECRET_SCHEMA_ATTRIBUTE_STRING},
     }};
@@ skipping 18 matching lines @@
 
   // Releases memory and restores LibsecretLoader to an uninitialized state.
   static void TearDown();
 
   // Set whether there is an old password that needs to be migrated from the
   // deprecated schema. Null means no such password. See crbug.com/639298
   static void SetDeprecatedOSCryptPassword(const char* value);
 
  private:
   // These methods are used to redirect calls through LibsecretLoader
-  static const gchar* mock_secret_value_get_text(MockSecretValue* value);
+  static const gchar* mock_secret_value_get_text(SecretValue* value);
 
   static gboolean mock_secret_password_store_sync(const SecretSchema* schema,
                                                   const gchar* collection,
                                                   const gchar* label,
                                                   const gchar* password,
                                                   GCancellable* cancellable,
                                                   GError** error,
                                                   ...);
 
   static void mock_secret_value_unref(gpointer value);
 
   static GList* mock_secret_service_search_sync(SecretService* service,
                                                 const SecretSchema* schema,
                                                 GHashTable* attributes,
                                                 SecretSearchFlags flags,
                                                 GCancellable* cancellable,
                                                 GError** error);
 
   static gboolean mock_secret_password_clear_sync(const SecretSchema* schema,
                                                   GCancellable* cancellable,
                                                   GError** error,
                                                   ...);
 
-  static MockSecretValue* mock_secret_item_get_secret(MockSecretItem* item);
+  static SecretValue* mock_secret_item_get_secret(SecretItem* item);
 
   // MockLibsecretLoader owns these objects.
   static MockSecretValue* stored_password_mock_ptr_;
   static MockSecretValue* deprecated_password_mock_ptr_;
 };
 
 MockSecretValue* MockLibsecretLoader::stored_password_mock_ptr_ = nullptr;
 MockSecretValue* MockLibsecretLoader::deprecated_password_mock_ptr_ = nullptr;
 
 const gchar* MockLibsecretLoader::mock_secret_value_get_text(
-    MockSecretValue* value) {
-  return value->c_str();
+    SecretValue* value) {
+  MockSecretValue* mock_value = reinterpret_cast<MockSecretValue*>(value);
+  return mock_value->c_str();
 }
 
 // static
 gboolean MockLibsecretLoader::mock_secret_password_store_sync(
     const SecretSchema* schema,
     const gchar* collection,
     const gchar* label,
     const gchar* password,
     GCancellable* cancellable,
     GError** error,
@@ skipping 41 matching lines @@
     GError** error,
     ...) {
   // We would only delete entries in the deprecated schema.
   EXPECT_STREQ(kKeystoreSchemaV1.name, schema->name);
   delete deprecated_password_mock_ptr_;
   deprecated_password_mock_ptr_ = nullptr;
   return true;
 }
 
 // static
-MockSecretValue* MockLibsecretLoader::mock_secret_item_get_secret(
-    MockSecretItem* item) {
-  return item;
+SecretValue* MockLibsecretLoader::mock_secret_item_get_secret(
+    SecretItem* item) {
+  static_assert(std::is_same<MockSecretValue, MockSecretItem>::value,
+                "mock_secret_item_get_secret() assumes that the only thing we "
+                "need from MockSercetItem is the MockSecretValue");
+  return reinterpret_cast<SecretValue*>(item);
 }
 
 // static
 bool MockLibsecretLoader::ResetForOSCrypt() {
   // Methods used by KeyStorageLibsecret
   secret_password_store_sync =
       &MockLibsecretLoader::mock_secret_password_store_sync;
-  secret_value_get_text = (decltype(&::secret_value_get_text)) &
-                          MockLibsecretLoader::mock_secret_value_get_text;
+  secret_value_get_text = &MockLibsecretLoader::mock_secret_value_get_text;
   secret_value_unref = &MockLibsecretLoader::mock_secret_value_unref;
   secret_service_search_sync =
       &MockLibsecretLoader::mock_secret_service_search_sync;
-  secret_item_get_secret =
-      (decltype(&::secret_item_get_secret))mock_secret_item_get_secret;
+  secret_item_get_secret = &MockLibsecretLoader::mock_secret_item_get_secret;
   // Used by Migrate()
   secret_password_clear_sync =
       &MockLibsecretLoader::mock_secret_password_clear_sync;
 
   delete stored_password_mock_ptr_;
   stored_password_mock_ptr_ = nullptr;
   libsecret_loaded_ = true;
 
   return true;
 }
@@ skipping 51 matching lines @@
 
 TEST_F(LibsecretTest, LibsecretMigratesFromSchemaV1ToV2) {
   KeyStorageLibsecret libsecret;
   MockLibsecretLoader::ResetForOSCrypt();
   MockLibsecretLoader::SetDeprecatedOSCryptPassword("swallow");
   std::string password = libsecret.GetKey();
   EXPECT_EQ("swallow", password);
 }
 
 }  // namespace