[lldb][LocateModuleCallback] Call locate module callback in Platform too

[splhack]

Summary

This is an enhancement for the locate module callback.
https://discourse.llvm.org/t/rfc-python-callback-for-target-get-module/71580/6

On Android remote platform, module UUID is resolved by
Platform::GetRemoteSharedModule. Which means the current
Target::CallLocateModuleCallbackIfSet() call undesirably is not able to pass the
module UUID to the locate module callback.

This diff moves the CallLocateModuleCallbackIfSet() implementation from Target
to Platform to allows both Target and Platform can call it. One is from the
current Target call site, and second is from Platform after resolving the module
UUID.

As the result of this change, the locate module callback may be called twice
for a same module on remote platforms. And it should be ok.

• First, without UUID.
  • The locate module callback is able to return a module and/or a symbol if the callback is able to do so without UUID.
  • The locate module callback is allowed to return an error if the callback requires UUID.
• Second, with UUID, if the first callback call did not return a module.

[splhack]

Remove wrong comment

[clayborg]

lgtm! I like this being in platform better

lldb/include/lldb/Target/Platform.h

public:
   LocateExecutableScriptingResources(Target *target, Module &module,
                                      Stream &feedback_stream);
 
   virtual Status GetSharedModule(
       const ModuleSpec &module_spec, Process *process,
       lldb::ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr,
       llvm::SmallVectorImpl<lldb::ModuleSP> *old_modules, bool *did_create_ptr);
 
+  void CallLocateModuleCallbackIfSet(const ModuleSpec &module_spec,
+                                     lldb::ModuleSP &module_sp,
+                                     FileSpec &symbol_file_spec,
+                                     bool *did_create_ptr);
+
   virtual bool GetModuleSpec(const FileSpec &module_file_spec,
                              const ArchSpec &arch, ModuleSpec &module_spec);
 
   virtual Status ConnectRemote(Args &args);
 
   virtual Status DisconnectRemote();
 
   /// Get the platform's supported architectures in the order in which they

lldb/include/lldb/Target/Target.h

private:
   void FinalizeFileActions(ProcessLaunchInfo &info);
 
   /// Return a recommended size for memory reads at \a addr, optimizing for
   /// cache usage.
   lldb::addr_t GetReasonableReadSize(const Address &addr);
 
   Target(const Target &) = delete;
   const Target &operator=(const Target &) = delete;
-
-private:
-  void CallLocateModuleCallbackIfSet(const ModuleSpec &module_spec,
-                                     lldb::ModuleSP &module_sp,
-                                     FileSpec &symbol_file_spec,
-                                     bool &did_create_module);
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_TARGET_TARGET_H

lldb/source/Target/Platform.cpp

Status Platform::GetRemoteSharedModule(const ModuleSpec &module_spec,
   }
 
   // If we are looking for a specific UUID, make sure resolved_module_spec has
   // the same one before we search.
   if (module_spec.GetUUID().IsValid()) {
     resolved_module_spec.GetUUID() = module_spec.GetUUID();
   }
 
-  // Trying to find a module by UUID on local file system.
-  const auto error = module_resolver(resolved_module_spec);
-  if (error.Fail()) {
-    if (GetCachedSharedModule(resolved_module_spec, module_sp, did_create_ptr))
-      return Status();
+  // Call locate module callback if set. This allows users to implement their
+  // own module cache system. For example, to leverage build system artifacts,
+  // to bypass pulling files from remote platform, or to search symbol files
+  // from symbol servers.
+  FileSpec symbol_file_spec;
+  CallLocateModuleCallbackIfSet(resolved_module_spec, module_sp,
+                                symbol_file_spec, did_create_ptr);
+  if (module_sp) {
+    // The module is loaded.
+    if (symbol_file_spec) {
+      // 1. module_sp:loaded, symbol_file_spec:set
+      //      The callback found a module file and a symbol file for this
+      //      resolved_module_spec. Set the symbol file to the module.
+      module_sp->SetSymbolFileFileSpec(symbol_file_spec);
+    } else {
+      // 2. module_sp:loaded, symbol_file_spec:empty
+      //      The callback only found a module file for this
+      //      resolved_module_spec.
+    }
   }
 
+  // The module is not loaded by CallLocateModuleCallbackIfSet.
+  // 3. module_sp:empty, symbol_file_spec:set
+  //      The callback only found a symbol file for the module. We continue to
+  //      find a module file for this resolved_module_spec. and we will call
+  //      module_sp->SetSymbolFileFileSpec with the symbol_file_spec later.
+  // 4. module_sp:empty, symbol_file_spec:empty
+  //      The callback is not set. Or the callback did not find any module
+  //      files nor any symbol files. Or the callback failed, or something
+  //      went wrong. We continue to find a module file for this
+  //      resolved_module_spec.
+
+  // Trying to find a module by UUID on local file system.
+  const Status error = module_resolver(resolved_module_spec);
+  if (error.Success()) {
+    if (module_sp && symbol_file_spec) {
+      // Set the symbol file to the module if the locate modudle callback was
+      // called and returned only a symbol file.
+      module_sp->SetSymbolFileFileSpec(symbol_file_spec);
+    }
     return error;
   }
 
+  // Fallback to call GetCachedSharedModule on failure.
+  if (GetCachedSharedModule(resolved_module_spec, module_sp, did_create_ptr)) {
+    if (module_sp && symbol_file_spec) {
+      // Set the symbol file to the module if the locate modudle callback was
+      // called and returned only a symbol file.
+      module_sp->SetSymbolFileFileSpec(symbol_file_spec);
+    }
+    return Status();
+  }
+
+  return Status("Failed to call GetCachedSharedModule");
+}
+
+void Platform::CallLocateModuleCallbackIfSet(const ModuleSpec &module_spec,
+                                             lldb::ModuleSP &module_sp,
+                                             FileSpec &symbol_file_spec,
+                                             bool *did_create_ptr) {
+  if (!m_locate_module_callback) {
+    // Locate module callback is not set.
+    return;
+  }
+
+  FileSpec module_file_spec;
+  Status error =
+      m_locate_module_callback(module_spec, module_file_spec, symbol_file_spec);
+
+  // Locate module callback is set and called. Check the error.
+  Log *log = GetLog(LLDBLog::Platform);
+  if (error.Fail()) {
+    LLDB_LOGF(log, "%s: locate module callback failed: %s",
+              LLVM_PRETTY_FUNCTION, error.AsCString());
+    return;
+  }
+
+  // The locate module callback was succeeded.
+  // Check the module_file_spec and symbol_file_spec values.
+  // 1. module:empty  symbol:empty  -> Failure
+  //    - The callback did not return any files.
+  // 2. module:exists symbol:exists -> Success
+  //    - The callback returned a module file and a symbol file.
+  // 3. module:exists symbol:empty  -> Success
+  //    - The callback returned only a module file.
+  // 4. module:empty  symbol:exists -> Success
+  //    - The callback returned only a symbol file.
+  //      For example, a breakpad symbol text file.
+  if (!module_file_spec && !symbol_file_spec) {
+    // This is '1. module:empty  symbol:empty  -> Failure'
+    // The callback did not return any files.
+    LLDB_LOGF(log,
+              "%s: locate module callback did not set both "
+              "module_file_spec and symbol_file_spec",
+              LLVM_PRETTY_FUNCTION);
+    return;
+  }
+
+  // If the callback returned a module file, it should exist.
+  if (module_file_spec && !FileSystem::Instance().Exists(module_file_spec)) {
+    LLDB_LOGF(log,
+              "%s: locate module callback set a non-existent file to "
+              "module_file_spec: %s",
+              LLVM_PRETTY_FUNCTION, module_file_spec.GetPath().c_str());
+    // Clear symbol_file_spec for the error.
+    symbol_file_spec.Clear();
+    return;
+  }
+
+  // If the callback returned a symbol file, it should exist.
+  if (symbol_file_spec && !FileSystem::Instance().Exists(symbol_file_spec)) {
+    LLDB_LOGF(log,
+              "%s: locate module callback set a non-existent file to "
+              "symbol_file_spec: %s",
+              LLVM_PRETTY_FUNCTION, symbol_file_spec.GetPath().c_str());
+    // Clear symbol_file_spec for the error.
+    symbol_file_spec.Clear();
+    return;
+  }
+
+  if (!module_file_spec && symbol_file_spec) {
+    // This is '4. module:empty  symbol:exists -> Success'
+    // The locate module callback returned only a symbol file. For example,
+    // a breakpad symbol text file. GetRemoteSharedModule will use this returned
+    // symbol_file_spec.
+    LLDB_LOGF(log, "%s: locate module callback succeeded: symbol=%s",
+              LLVM_PRETTY_FUNCTION, symbol_file_spec.GetPath().c_str());
+    return;
+  }
+
+  // This is one of the following.
+  // - 2. module:exists symbol:exists -> Success
+  //    - The callback returned a module file and a symbol file.
+  // - 3. module:exists symbol:empty  -> Success
+  //    - The callback returned Only a module file.
+  // Load the module file.
+  auto cached_module_spec(module_spec);
+  cached_module_spec.GetUUID().Clear(); // Clear UUID since it may contain md5
+                                        // content hash instead of real UUID.
+  cached_module_spec.GetFileSpec() = module_file_spec;
+  cached_module_spec.GetPlatformFileSpec() = module_spec.GetFileSpec();
+  cached_module_spec.SetObjectOffset(0);
+
+  error = ModuleList::GetSharedModule(cached_module_spec, module_sp, nullptr,
+                                      nullptr, did_create_ptr, false);
+  if (error.Success() && module_sp) {
+    // Succeeded to load the module file.
+    LLDB_LOGF(log, "%s: locate module callback succeeded: module=%s symbol=%s",
+              LLVM_PRETTY_FUNCTION, module_file_spec.GetPath().c_str(),
+              symbol_file_spec.GetPath().c_str());
+  } else {
+    LLDB_LOGF(log,
+              "%s: locate module callback succeeded but failed to load: "
+              "module=%s symbol=%s",
+              LLVM_PRETTY_FUNCTION, module_file_spec.GetPath().c_str(),
+              symbol_file_spec.GetPath().c_str());
+    // Clear module_sp and symbol_file_spec for the error.
+    module_sp.reset();
+    symbol_file_spec.Clear();
+  }
+}
+
 bool Platform::GetCachedSharedModule(const ModuleSpec &module_spec,
                                      lldb::ModuleSP &module_sp,
                                      bool *did_create_ptr) {
   if (IsHost() || !GetGlobalPlatformProperties().GetUseModuleCache() ||
       !GetGlobalPlatformProperties().GetModuleCacheDirectory())
     return false;
 
   Log *log = GetLog(LLDBLog::Platform);

lldb/source/Target/Target.cpp

if (!module_sp) {
     bool did_create_module = false;
     FileSpecList search_paths = GetExecutableSearchPaths();
     FileSpec symbol_file_spec;
 
     // Call locate module callback if set. This allows users to implement their
     // own module cache system. For example, to leverage build system artifacts,
     // to bypass pulling files from remote platform, or to search symbol files
     // from symbol servers.
-    CallLocateModuleCallbackIfSet(module_spec, module_sp, symbol_file_spec,
-                                  did_create_module);
+    if (m_platform_sp)
+      m_platform_sp->CallLocateModuleCallbackIfSet(
+          module_spec, module_sp, symbol_file_spec, &did_create_module);
 
     // The result of this CallLocateModuleCallbackIfSet is one of the following.
     // 1. module_sp:loaded, symbol_file_spec:set
     //      The callback found a module file and a symbol file for the
     //      module_spec. We will call module_sp->SetSymbolFileFileSpec with
     //      the symbol_file_spec later.
     // 2. module_sp:loaded, symbol_file_spec:empty
     //      The callback only found a module file for the module_spec.
     // 3. module_sp:empty, symbol_file_spec:set
     //      The callback only found a symbol file for the module. We continue
     //      to find a module file for this module_spec and we will call
     //      module_sp->SetSymbolFileFileSpec with the symbol_file_spec later.
     // 4. module_sp:empty, symbol_file_spec:empty
-    //      The callback is not set. Or the callback did not find any module
-    //      files nor any symbol files. Or the callback failed, or something
-    //      went wrong. We continue to find a module file for this module_spec.
+    //      Platform does not exist, the callback is not set, the callback did
+    //      not find any module files nor any symbol files, the callback failed,
+    //      or something went wrong. We continue to find a module file for this
+    //      module_spec.
 
     if (!module_sp) {
       // If there are image search path entries, try to use them to acquire a
       // suitable image.
       if (m_image_search_paths.GetSize()) {
         ModuleSpec transformed_spec(module_spec);
         ConstString transformed_dir;
         if (m_image_search_paths.RemapPath(
if (module_sp) {
         module_sp.reset();
     }
   }
   if (error_ptr)
     *error_ptr = error;
   return module_sp;
 }
 
-void Target::CallLocateModuleCallbackIfSet(const ModuleSpec &module_spec,
-                                           lldb::ModuleSP &module_sp,
-                                           FileSpec &symbol_file_spec,
-                                           bool &did_create_module) {
-  if (!m_platform_sp)
-    return;
-
-  Platform::LocateModuleCallback locate_module_callback =
-      m_platform_sp->GetLocateModuleCallback();
-  if (!locate_module_callback)
-    return;
-
-  FileSpec module_file_spec;
-  Status error =
-      locate_module_callback(module_spec, module_file_spec, symbol_file_spec);
-
-  // Locate module callback is set and called. Check the error.
-  Log *log = GetLog(LLDBLog::Target);
-  if (error.Fail()) {
-    LLDB_LOGF(log, "%s: locate module callback failed: %s",
-              LLVM_PRETTY_FUNCTION, error.AsCString());
-    return;
-  }
-
-  // The locate module callback was succeeded. It should returned
-  // 1. a combination of a module file and a symbol file.
-  // 2. or only a module file.
-  // 3. or only a symbol file. For example, a breakpad symbol text file.
-  //
-  // Check the module_file_spec and symbol_file_spec values.
-  // 1. module:empty  symbol:empty  -> Invalid
-  // 2. module:exists symbol:exists -> Success
-  // 3. module:exists symbol:empty  -> Success
-  // 4. module:empty  symbol:exists -> Success
-  if (!module_file_spec && !symbol_file_spec) {
-    // This is '1. module:empty symbol:empty -> Invalid'.
-    LLDB_LOGF(log,
-              "%s: locate module callback did not set both "
-              "module_file_spec and symbol_file_spec",
-              LLVM_PRETTY_FUNCTION);
-    return;
-  }
-
-  // The module file should exist.
-  if (module_file_spec && !FileSystem::Instance().Exists(module_file_spec)) {
-    LLDB_LOGF(log,
-              "%s: locate module callback set a non-existent file to "
-              "module_file_spec: %s",
-              LLVM_PRETTY_FUNCTION, module_file_spec.GetPath().c_str());
-    // Clear symbol_file_spec for the error.
-    symbol_file_spec.Clear();
-    return;
-  }
-
-  // The symbol file should exist.
-  if (symbol_file_spec && !FileSystem::Instance().Exists(symbol_file_spec)) {
-    LLDB_LOGF(log,
-              "%s: locate module callback set a non-existent file to "
-              "symbol_file_spec: %s",
-              LLVM_PRETTY_FUNCTION, symbol_file_spec.GetPath().c_str());
-    // Clear symbol_file_spec for the error.
-    symbol_file_spec.Clear();
-    return;
-  }
-
-  if (!module_file_spec && symbol_file_spec) {
-    // This is '4. module:empty symbol:exists -> Success'.
-    // The locate module callback returned only a symbol file. For example,
-    // a breakpad symbol text file. GetOrCreateModule will use this returned
-    // symbol_file_spec.
-    LLDB_LOGF(log, "%s: locate module callback succeeded: symbol=%s",
-              LLVM_PRETTY_FUNCTION, symbol_file_spec.GetPath().c_str());
-    return;
-  }
-
-  // The locate module callback returned
-  // - '2. module:exists symbol:exists -> Success'
-  //   - a combination of a module file and a symbol file.
-  // - Or '3. module:exists symbol:empty -> Success'
-  //   - only a module file.
-  // Load the module file.
-  auto cached_module_spec(module_spec);
-  cached_module_spec.GetUUID().Clear(); // Clear UUID since it may contain md5
-                                        // content hash instead of real UUID.
-  cached_module_spec.GetFileSpec() = module_file_spec;
-  cached_module_spec.GetPlatformFileSpec() = module_spec.GetFileSpec();
-  cached_module_spec.SetObjectOffset(0);
-
-  error = ModuleList::GetSharedModule(cached_module_spec, module_sp, nullptr,
-                                      nullptr, &did_create_module, false);
-  if (error.Success() && module_sp) {
-    // Succeeded to load the module file.
-    LLDB_LOGF(log, "%s: locate module callback succeeded: module=%s symbol=%s",
-              LLVM_PRETTY_FUNCTION, module_file_spec.GetPath().c_str(),
-              symbol_file_spec.GetPath().c_str());
-  } else {
-    LLDB_LOGF(log,
-              "%s: locate module callback succeeded but failed to load: "
-              "module=%s symbol=%s",
-              LLVM_PRETTY_FUNCTION, module_file_spec.GetPath().c_str(),
-              symbol_file_spec.GetPath().c_str());
-    // Clear module_sp and symbol_file_spec for the error.
-    module_sp.reset();
-    symbol_file_spec.Clear();
-  }
-}
-
 TargetSP Target::CalculateTarget() { return shared_from_this(); }
 
 ProcessSP Target::CalculateProcess() { return m_process_sp; }
 
 ThreadSP Target::CalculateThread() { return ThreadSP(); }
 
 StackFrameSP Target::CalculateStackFrame() { return StackFrameSP(); }
 

lldb/unittests/Target/LocateModuleCallbackTest.cpp

PluginManager::RegisterPlugin(k_process_plugin, "",
                                   MockProcessCreateInstance);
     m_process_sp =
         m_target_sp->CreateProcess(Listener::MakeListener("test-listener"),
                                    k_process_plugin, /*crash_file=*/nullptr,
                                    /*can_connect=*/true);
     EXPECT_TRUE(m_process_sp);
 
     m_module_spec = GetTestModuleSpec();
+    m_module_spec_without_uuid = ModuleSpec(GetRemotePath(), ArchSpec(k_arch));
   }
 
   void TearDown() override {
     if (m_module_sp)
       ModuleList::RemoveSharedModule(m_module_sp);
   }
 
   void CheckNoCallback() {
     EXPECT_FALSE(m_platform_sp->GetLocateModuleCallback());
     EXPECT_EQ(m_callback_call_count, 0);
   }
 
   void CheckCallbackArgs(const ModuleSpec &module_spec,
-                         FileSpec &module_file_spec,
-                         FileSpec &symbol_file_spec) {
-    EXPECT_TRUE(m_module_spec.Matches(module_spec,
+                         FileSpec &module_file_spec, FileSpec &symbol_file_spec,
+                         const ModuleSpec &expected_module_spec,
+                         int expected_callback_call_count) {
+    EXPECT_TRUE(expected_module_spec.Matches(module_spec,
                                              /*exact_arch_match=*/true));
     EXPECT_FALSE(module_file_spec);
     EXPECT_FALSE(symbol_file_spec);
 
-    EXPECT_EQ(m_callback_call_count, 0);
-    m_callback_call_count++;
+    EXPECT_EQ(++m_callback_call_count, expected_callback_call_count);
+  }
+
+  void CheckCallbackArgsWithUUID(const ModuleSpec &module_spec,
+                                 FileSpec &module_file_spec,
+                                 FileSpec &symbol_file_spec,
+                                 int expected_callback_call_count) {
+    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec,
+                      m_module_spec, expected_callback_call_count);
+    EXPECT_TRUE(module_spec.GetUUID().IsValid());
+  }
+
+  void CheckCallbackArgsWithoutUUID(const ModuleSpec &module_spec,
+                                    FileSpec &module_file_spec,
+                                    FileSpec &symbol_file_spec,
+                                    int expected_callback_call_count) {
+    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec,
+                      m_module_spec_without_uuid, expected_callback_call_count);
+    EXPECT_FALSE(module_spec.GetUUID().IsValid());
   }
 
 protected:
   FileSpec m_test_dir;
   DebuggerSP m_debugger_sp;
   PlatformSP m_platform_sp;
   TargetSP m_target_sp;
   ProcessSP m_process_sp;
   ModuleSpec m_module_spec;
+  ModuleSpec m_module_spec_without_uuid;
   ModuleSP m_module_sp;
   int m_callback_call_count = 0;
 };
 
 } // namespace
 
 TEST_F(LocateModuleCallbackTest, GetOrCreateModuleWithCachedModule) {
   // The module file is cached, and the locate module callback is not set.

 }
 
 TEST_F(LocateModuleCallbackTest, GetOrCreateModuleCallbackFailureNoCache) {
   // The cache dir is empty, also the locate module callback fails for some
   // reason. GetOrCreateModule should fail because PlatformAndroid tries to
   // download the module and fails.
   BuildEmptyCacheDir(m_test_dir);
 
-  m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
-                                                FileSpec &module_file_spec,
-                                                FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+        CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                  symbol_file_spec, ++callback_call_count);
         return Status("The locate module callback failed");
       });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
   ASSERT_FALSE(m_module_sp);
 }
 
 TEST_F(LocateModuleCallbackTest, GetOrCreateModuleCallbackFailureCached) {
   // The module file is cached, so GetOrCreateModule should succeed to return
   // the module from the cache even though the locate module callback fails for
   // some reason.
   FileSpec uuid_view = BuildCacheDir(m_test_dir);
 
-  m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
-                                                FileSpec &module_file_spec,
-                                                FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+        CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                  symbol_file_spec, ++callback_call_count);
         return Status("The locate module callback failed");
       });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
   CheckModule(m_module_sp);
   ASSERT_EQ(m_module_sp->GetFileSpec(), uuid_view);
   ASSERT_FALSE(m_module_sp->GetSymbolFileFileSpec());
   CheckStrippedSymbol(m_module_sp);
 }
 
 TEST_F(LocateModuleCallbackTest, GetOrCreateModuleCallbackNoFiles) {
   // The module file is cached, so GetOrCreateModule should succeed to return
   // the module from the cache even though the locate module callback returns
   // no files.
   FileSpec uuid_view = BuildCacheDir(m_test_dir);
 
-  m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
-                                                FileSpec &module_file_spec,
-                                                FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+        CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                  symbol_file_spec, ++callback_call_count);
         // The locate module callback succeeds but it does not set
         // module_file_spec nor symbol_file_spec.
         return Status();
       });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
   CheckModule(m_module_sp);
   ASSERT_EQ(m_module_sp->GetFileSpec(), uuid_view);
   ASSERT_FALSE(m_module_sp->GetSymbolFileFileSpec());
   CheckStrippedSymbol(m_module_sp);
   ModuleList::RemoveSharedModule(m_module_sp);
 }
 
 TEST_F(LocateModuleCallbackTest, GetOrCreateModuleCallbackNonExistentModule) {
   // The module file is cached, so GetOrCreateModule should succeed to return
   // the module from the cache even though the locate module callback returns
   // non-existent module file.
   FileSpec uuid_view = BuildCacheDir(m_test_dir);
 
-  m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
-                                                FileSpec &module_file_spec,
-                                                FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+        CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                  symbol_file_spec, ++callback_call_count);
         module_file_spec.SetPath("/this path does not exist");
         return Status();
       });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
   CheckModule(m_module_sp);
   ASSERT_EQ(m_module_sp->GetFileSpec(), uuid_view);
   ASSERT_FALSE(m_module_sp->GetSymbolFileFileSpec());
   CheckStrippedSymbol(m_module_sp);
   ModuleList::RemoveSharedModule(m_module_sp);
 }
 
 TEST_F(LocateModuleCallbackTest, GetOrCreateModuleCallbackNonExistentSymbol) {
   // The module file is cached, so GetOrCreateModule should succeed to return
   // the module from the cache even though the locate module callback returns
   // non-existent symbol file.
   FileSpec uuid_view = BuildCacheDir(m_test_dir);
 
-  m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
-                                                FileSpec &module_file_spec,
-                                                FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+        CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                  symbol_file_spec, ++callback_call_count);
         // The locate module callback returns a right module file.
         module_file_spec.SetPath(GetInputFilePath(k_module_file));
         // But it returns non-existent symbols file.
         symbol_file_spec.SetPath("/this path does not exist");
         return Status();
       });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
   CheckModule(m_module_sp);
   ASSERT_EQ(m_module_sp->GetFileSpec(), uuid_view);
   ASSERT_TRUE(m_module_sp->GetSymbolFileFileSpec().GetPath().empty());
   CheckStrippedSymbol(m_module_sp);
   ModuleList::RemoveSharedModule(m_module_sp);
 }
 
 TEST_F(LocateModuleCallbackTest, GetOrCreateModuleCallbackSuccessWithModule) {
   // The locate module callback returns a module file, GetOrCreateModule should
   // succeed to return the module from the Inputs directory.
   BuildEmptyCacheDir(m_test_dir);
 
   m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
                                                 FileSpec &module_file_spec,
                                                 FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+    CheckCallbackArgsWithUUID(module_spec, module_file_spec, symbol_file_spec,
+                              1);
     module_file_spec.SetPath(GetInputFilePath(k_module_file));
     return Status();
   });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
   CheckModule(m_module_sp);
   ASSERT_EQ(m_module_sp->GetFileSpec(),
             FileSpec(GetInputFilePath(k_module_file)));
   ASSERT_FALSE(m_module_sp->GetSymbolFileFileSpec());
   CheckStrippedSymbol(m_module_sp);
   ModuleList::RemoveSharedModule(m_module_sp);
 }
 
 TEST_F(LocateModuleCallbackTest,
        GetOrCreateModuleCallbackSuccessWithSymbolAsModule) {
   // The locate module callback returns the symbol file as a module file. It
   // should work since the sections and UUID of the symbol file are the exact
   // same with the module file, GetOrCreateModule should succeed to return the
   // module with the symbol file from Inputs directory.
   BuildEmptyCacheDir(m_test_dir);
 
   m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
                                                 FileSpec &module_file_spec,
                                                 FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+    CheckCallbackArgsWithUUID(module_spec, module_file_spec, symbol_file_spec,
+                              1);
     module_file_spec.SetPath(GetInputFilePath(k_symbol_file));
     return Status();
   });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
   CheckModule(m_module_sp);
   ASSERT_EQ(m_module_sp->GetFileSpec(),
             FileSpec(GetInputFilePath(k_symbol_file)));
   ASSERT_FALSE(m_module_sp->GetSymbolFileFileSpec());
   CheckUnstrippedSymbol(m_module_sp);
   ModuleList::RemoveSharedModule(m_module_sp);
 }
 
 TEST_F(LocateModuleCallbackTest,
        GetOrCreateModuleCallbackSuccessWithSymbolAsModuleAndSymbol) {
   // The locate module callback returns a symbol file as both a module file and
   // a symbol file. It should work since the sections and UUID of the symbol
   // file are the exact same with the module file, GetOrCreateModule should
   // succeed to return the module with the symbol file from Inputs directory.
   BuildEmptyCacheDir(m_test_dir);
 
   m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
                                                 FileSpec &module_file_spec,
                                                 FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+    CheckCallbackArgsWithUUID(module_spec, module_file_spec, symbol_file_spec,
+                              1);
     module_file_spec.SetPath(GetInputFilePath(k_symbol_file));
     symbol_file_spec.SetPath(GetInputFilePath(k_symbol_file));
     return Status();
   });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
   CheckModule(m_module_sp);
   ASSERT_EQ(m_module_sp->GetFileSpec(),
TEST_F(LocateModuleCallbackTest,
   // The locate module callback returns a module file and a symbol file,
   // GetOrCreateModule should succeed to return the module from Inputs
   // directory, along with the symbol file.
   BuildEmptyCacheDir(m_test_dir);
 
   m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
                                                 FileSpec &module_file_spec,
                                                 FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+    CheckCallbackArgsWithUUID(module_spec, module_file_spec, symbol_file_spec,
+                              1);
     module_file_spec.SetPath(GetInputFilePath(k_module_file));
     symbol_file_spec.SetPath(GetInputFilePath(k_symbol_file));
     return Status();
   });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
   CheckModule(m_module_sp);
   ASSERT_EQ(m_module_sp->GetFileSpec(),
TEST_F(LocateModuleCallbackTest,
   // The locate module callback returns a module file and a breakpad symbol
   // file, GetOrCreateModule should succeed to return the module with the symbol
   // file from Inputs directory.
   BuildEmptyCacheDir(m_test_dir);
 
   m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
                                                 FileSpec &module_file_spec,
                                                 FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+    CheckCallbackArgsWithUUID(module_spec, module_file_spec, symbol_file_spec,
+                              1);
     module_file_spec.SetPath(GetInputFilePath(k_module_file));
     symbol_file_spec.SetPath(GetInputFilePath(k_breakpad_symbol_file));
     return Status();
   });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
   CheckModule(m_module_sp);
   ASSERT_EQ(m_module_sp->GetFileSpec(),
             FileSpec(GetInputFilePath(k_module_file)));
   ASSERT_EQ(m_module_sp->GetSymbolFileFileSpec(),
             FileSpec(GetInputFilePath(k_breakpad_symbol_file)));
   CheckUnstrippedSymbol(m_module_sp);
   ModuleList::RemoveSharedModule(m_module_sp);
 }
 
 TEST_F(LocateModuleCallbackTest,
        GetOrCreateModuleCallbackSuccessWithOnlySymbol) {
   // The get callback returns only a symbol file, and the module is cached,
   // GetOrCreateModule should succeed to return the module from the cache
   // along with the symbol file from the Inputs directory.
   FileSpec uuid_view = BuildCacheDir(m_test_dir);
 
-  m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
-                                                FileSpec &module_file_spec,
-                                                FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+        CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                  symbol_file_spec, ++callback_call_count);
         symbol_file_spec.SetPath(GetInputFilePath(k_symbol_file));
         return Status();
       });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
   CheckModule(m_module_sp);
   ASSERT_EQ(m_module_sp->GetFileSpec(), uuid_view);
   ASSERT_EQ(m_module_sp->GetSymbolFileFileSpec(),
             FileSpec(GetInputFilePath(k_symbol_file)));
   CheckUnstrippedSymbol(m_module_sp);
   ModuleList::RemoveSharedModule(m_module_sp);
 }
 
 TEST_F(LocateModuleCallbackTest,
        GetOrCreateModuleCallbackSuccessWithOnlyBreakpadSymbol) {
   // The get callback returns only a breakpad symbol file, and the module is
   // cached, GetOrCreateModule should succeed to return the module from the
   // cache along with the symbol file from the Inputs directory.
   FileSpec uuid_view = BuildCacheDir(m_test_dir);
 
-  m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
-                                                FileSpec &module_file_spec,
-                                                FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+        CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                  symbol_file_spec, ++callback_call_count);
         symbol_file_spec.SetPath(GetInputFilePath(k_breakpad_symbol_file));
         return Status();
       });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
+  CheckModule(m_module_sp);
+  ASSERT_EQ(m_module_sp->GetFileSpec(), uuid_view);
+  ASSERT_EQ(m_module_sp->GetSymbolFileFileSpec(),
+            FileSpec(GetInputFilePath(k_breakpad_symbol_file)));
+  CheckUnstrippedSymbol(m_module_sp);
+  ModuleList::RemoveSharedModule(m_module_sp);
+}
+
+TEST_F(LocateModuleCallbackTest,
+       GetOrCreateModuleCallbackSuccessWithMultipleSymbols) {
+  // The get callback returns only a symbol file. The first call returns
+  // a breakpad symbol file and the second call returns a symbol file.
+  // Also the module is cached, so GetOrCreateModule should succeed to return
+  // the module from the cache along with the breakpad symbol file from the
+  // Inputs directory because GetOrCreateModule will use the first symbol file
+  // from the callback.
+  FileSpec uuid_view = BuildCacheDir(m_test_dir);
+
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+                                   FileSpec &module_file_spec,
+                                   FileSpec &symbol_file_spec) {
+        CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                  symbol_file_spec, ++callback_call_count);
+        symbol_file_spec.SetPath(GetInputFilePath(
+            callback_call_count == 1 ? k_breakpad_symbol_file : k_symbol_file));
+        return Status();
+      });
+
+  m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
   CheckModule(m_module_sp);
   ASSERT_EQ(m_module_sp->GetFileSpec(), uuid_view);
   ASSERT_EQ(m_module_sp->GetSymbolFileFileSpec(),
             FileSpec(GetInputFilePath(k_breakpad_symbol_file)));
   CheckUnstrippedSymbol(m_module_sp);
   ModuleList::RemoveSharedModule(m_module_sp);
 }
 
 TEST_F(LocateModuleCallbackTest,
        GetOrCreateModuleNoCacheWithCallbackOnlySymbol) {
   // The get callback returns only a symbol file, but the module is not
   // cached, GetOrCreateModule should fail because of the missing module.
   BuildEmptyCacheDir(m_test_dir);
 
-  m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
-                                                FileSpec &module_file_spec,
-                                                FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+        CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                  symbol_file_spec, ++callback_call_count);
         symbol_file_spec.SetPath(GetInputFilePath(k_symbol_file));
         return Status();
       });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
   ASSERT_FALSE(m_module_sp);
 }
 
 TEST_F(LocateModuleCallbackTest,
        GetOrCreateModuleNoCacheWithCallbackOnlyBreakpadSymbol) {
   // The get callback returns only a breakpad symbol file, but the module is not
   // cached, GetOrCreateModule should fail because of the missing module.
   BuildEmptyCacheDir(m_test_dir);
 
-  m_platform_sp->SetLocateModuleCallback([this](const ModuleSpec &module_spec,
-                                                FileSpec &module_file_spec,
-                                                FileSpec &symbol_file_spec) {
-    CheckCallbackArgs(module_spec, module_file_spec, symbol_file_spec);
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+        CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                  symbol_file_spec, ++callback_call_count);
         symbol_file_spec.SetPath(GetInputFilePath(k_breakpad_symbol_file));
         return Status();
       });
 
   m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec, /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
   ASSERT_FALSE(m_module_sp);
 }
+
+TEST_F(LocateModuleCallbackTest,
+       GetOrCreateModuleCallbackSuccessWithModuleByPlatformUUID) {
+  // This is a simulation for Android remote platform debugging.
+  // The locate module callback first call fails because module_spec does not
+  // have UUID. Then, the callback second call returns a module file because the
+  // platform resolved the module_spec UUID from the target process.
+  // GetOrCreateModule should succeed to return the module from the Inputs
+  // directory.
+  BuildEmptyCacheDir(m_test_dir);
+
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+                                   FileSpec &module_file_spec,
+                                   FileSpec &symbol_file_spec) {
+        callback_call_count++;
+        if (callback_call_count == 1) {
+          // The module_spec does not have UUID on the first call.
+          CheckCallbackArgsWithoutUUID(module_spec, module_file_spec,
+                                       symbol_file_spec, callback_call_count);
+          return Status("Ignored empty UUID");
+        } else {
+          // The module_spec has UUID on the second call.
+          CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                    symbol_file_spec, callback_call_count);
+          module_file_spec.SetPath(GetInputFilePath(k_module_file));
+          return Status();
+        }
+      });
+
+  m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec_without_uuid,
+                                               /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
+  CheckModule(m_module_sp);
+  ASSERT_EQ(m_module_sp->GetFileSpec(),
+            FileSpec(GetInputFilePath(k_module_file)));
+  ASSERT_FALSE(m_module_sp->GetSymbolFileFileSpec());
+  CheckStrippedSymbol(m_module_sp);
+  ModuleList::RemoveSharedModule(m_module_sp);
+}
+
+TEST_F(LocateModuleCallbackTest,
+       GetOrCreateModuleCallbackSuccessWithSymbolByPlatformUUID) {
+  // Same as GetOrCreateModuleCallbackSuccessWithModuleByPlatformUUID,
+  // but with a symbol file. GetOrCreateModule should succeed to return the
+  // module file and the symbol file from the Inputs directory.
+  BuildEmptyCacheDir(m_test_dir);
+
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+                                   FileSpec &module_file_spec,
+                                   FileSpec &symbol_file_spec) {
+        callback_call_count++;
+        if (callback_call_count == 1) {
+          // The module_spec does not have UUID on the first call.
+          CheckCallbackArgsWithoutUUID(module_spec, module_file_spec,
+                                       symbol_file_spec, callback_call_count);
+          return Status("Ignored empty UUID");
+        } else {
+          // The module_spec has UUID on the second call.
+          CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                    symbol_file_spec, callback_call_count);
+          module_file_spec.SetPath(GetInputFilePath(k_module_file));
+          symbol_file_spec.SetPath(GetInputFilePath(k_symbol_file));
+          return Status();
+        }
+      });
+
+  m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec_without_uuid,
+                                               /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
+  CheckModule(m_module_sp);
+  ASSERT_EQ(m_module_sp->GetFileSpec(),
+            FileSpec(GetInputFilePath(k_module_file)));
+  ASSERT_EQ(m_module_sp->GetSymbolFileFileSpec(),
+            FileSpec(GetInputFilePath(k_symbol_file)));
+  CheckUnstrippedSymbol(m_module_sp);
+  ModuleList::RemoveSharedModule(m_module_sp);
+}
+
+TEST_F(LocateModuleCallbackTest,
+       GetOrCreateModuleCallbackSuccessWithBreakpadSymbolByPlatformUUID) {
+  // Same as GetOrCreateModuleCallbackSuccessWithModuleByPlatformUUID,
+  // but with a breakpad symbol file. GetOrCreateModule should succeed to return
+  // the module file and the symbol file from the Inputs directory.
+  BuildEmptyCacheDir(m_test_dir);
+
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+                                   FileSpec &module_file_spec,
+                                   FileSpec &symbol_file_spec) {
+        callback_call_count++;
+        if (callback_call_count == 1) {
+          // The module_spec does not have UUID on the first call.
+          CheckCallbackArgsWithoutUUID(module_spec, module_file_spec,
+                                       symbol_file_spec, callback_call_count);
+          return Status("Ignored empty UUID");
+        } else {
+          // The module_spec has UUID on the second call.
+          CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                    symbol_file_spec, callback_call_count);
+          module_file_spec.SetPath(GetInputFilePath(k_module_file));
+          symbol_file_spec.SetPath(GetInputFilePath(k_breakpad_symbol_file));
+          return Status();
+        }
+      });
+
+  m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec_without_uuid,
+                                               /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
+  CheckModule(m_module_sp);
+  ASSERT_EQ(m_module_sp->GetFileSpec(),
+            FileSpec(GetInputFilePath(k_module_file)));
+  ASSERT_EQ(m_module_sp->GetSymbolFileFileSpec(),
+            FileSpec(GetInputFilePath(k_breakpad_symbol_file)));
+  CheckUnstrippedSymbol(m_module_sp);
+  ModuleList::RemoveSharedModule(m_module_sp);
+}
+
+TEST_F(LocateModuleCallbackTest,
+       GetOrCreateModuleCallbackSuccessWithOnlyBreakpadSymbolByPlatformUUID) {
+  // This is a simulation for Android remote platform debugging.
+  // The locate module callback first call fails because module_spec does not
+  // have UUID. Then, the callback second call returns a breakpad symbol file
+  // for the UUID from the target process. GetOrCreateModule should succeed to
+  // return the module from the cache along with the symbol file from the Inputs
+  // directory.
+  FileSpec uuid_view = BuildCacheDir(m_test_dir);
+
+  int callback_call_count = 0;
+  m_platform_sp->SetLocateModuleCallback(
+      [this, &callback_call_count](const ModuleSpec &module_spec,
+                                   FileSpec &module_file_spec,
+                                   FileSpec &symbol_file_spec) {
+        callback_call_count++;
+        if (callback_call_count == 1) {
+          // The module_spec does not have UUID on the first call.
+          CheckCallbackArgsWithoutUUID(module_spec, module_file_spec,
+                                       symbol_file_spec, callback_call_count);
+          return Status("Ignored empty UUID");
+        } else {
+          // The module_spec has UUID on the second call.
+          CheckCallbackArgsWithUUID(module_spec, module_file_spec,
+                                    symbol_file_spec, callback_call_count);
+          symbol_file_spec.SetPath(GetInputFilePath(k_breakpad_symbol_file));
+          return Status();
+        }
+      });
+
+  m_module_sp = m_target_sp->GetOrCreateModule(m_module_spec_without_uuid,
+                                               /*notify=*/false);
+  ASSERT_EQ(callback_call_count, 2);
+  CheckModule(m_module_sp);
+  ASSERT_EQ(m_module_sp->GetFileSpec(), uuid_view);
+  ASSERT_EQ(m_module_sp->GetSymbolFileFileSpec(),
+            FileSpec(GetInputFilePath(k_breakpad_symbol_file)));
+  CheckUnstrippedSymbol(m_module_sp);
+  ModuleList::RemoveSharedModule(m_module_sp);
+}