Remove unused PathMapper struct and arguments.

Author: mstange

samply-symbols/src/dwarf.rs

@@ -7,25 +7,22 @@ use gimli::{DwarfPackage, EndianSlice, Reader, RunTimeEndian, SectionId};
 use object::read::ReadRef;
 use object::CompressionFormat;
 
-use crate::path_mapper::PathMapper;
 use crate::shared::FrameDebugInfo;
 use crate::{demangle, Error, SourceFilePath};
 
 pub fn get_frames<R: Reader>(
     address: u64,
     context: Option<&addr2line::Context<R>>,
-    path_mapper: &mut PathMapper<()>,
 ) -> Option<Vec<FrameDebugInfo>> {
     let frame_iter = context?.find_frames(address).skip_all_loads().ok()?;
-    convert_frames(frame_iter, path_mapper)
+    convert_frames(frame_iter)
 }
 
 pub fn convert_frames<'a, R: gimli::Reader>(
     frame_iter: impl FallibleIterator<Item = addr2line::Frame<'a, R>>,
-    path_mapper: &mut PathMapper<()>,
 ) -> Option<Vec<FrameDebugInfo>> {
     let frames: Vec<_> = frame_iter
-        .map(|f| Ok(convert_stack_frame(f, &mut *path_mapper)))
+        .map(|f| Ok(convert_stack_frame(f)))
         .collect()
         .ok()?;
 
@@ -36,10 +33,7 @@ pub fn convert_frames<'a, R: gimli::Reader>(
     }
 }
 
-pub fn convert_stack_frame<R: gimli::Reader>(
-    frame: addr2line::Frame<R>,
-    path_mapper: &mut PathMapper<()>,
-) -> FrameDebugInfo {
+pub fn convert_stack_frame<R: gimli::Reader>(frame: addr2line::Frame<R>) -> FrameDebugInfo {
     let function = match frame.function {
         Some(function_name) => {
             if let Ok(name) = function_name.raw_name() {
@@ -50,10 +44,11 @@ pub fn convert_stack_frame<R: gimli::Reader>(
         }
         None => None,
     };
-    let file_path = frame.location.as_ref().and_then(|l| l.file).map(|file| {
-        let _mapped_path = path_mapper.map_path(file); // TODO: remove path mapper everywhere
-        SourceFilePath::RawPath(file.into())
-    });
+    let file_path = frame
+        .location
+        .as_ref()
+        .and_then(|l| l.file)
+        .map(|file| SourceFilePath::RawPath(file.into()));
 
     FrameDebugInfo {
         function,

samply-symbols/src/external_file.rs

@@ -8,7 +8,6 @@ use yoke_derive::Yokeable;
 
 use crate::dwarf::{get_frames, Addr2lineContextData};
 use crate::error::Error;
-use crate::path_mapper::PathMapper;
 use crate::shared::{
     ExternalFileAddressInFileRef, FileAndPathHelper, FileContents, FileContentsWrapper,
     FrameDebugInfo,
@@ -118,7 +117,6 @@ impl<F: FileContents> ExternalFileOuter<F> {
         Ok(ExternalFileInner {
             external_file: self,
             member_contexts,
-            path_mapper: Mutex::new(PathMapper::new()),
         })
     }
 }
@@ -145,23 +143,21 @@ trait ExternalFileInnerTrait {
 struct ExternalFileInner<'a, T: FileContents> {
     external_file: &'a ExternalFileOuter<T>,
     member_contexts: ExternalFileMemberContexts<'a>,
-    path_mapper: Mutex<PathMapper<()>>,
 }
 
 impl<F: FileContents> ExternalFileInnerTrait for ExternalFileInner<'_, F> {
     fn lookup(
         &self,
         external_file_address: &ExternalFileAddressInFileRef,
     ) -> Option<Vec<FrameDebugInfo>> {
-        let mut path_mapper = self.path_mapper.lock().unwrap();
         match (&self.member_contexts, external_file_address) {
             (
                 ExternalFileMemberContexts::SingleObject(context),
                 ExternalFileAddressInFileRef::MachoOsoObject {
                     symbol_name,
                     offset_from_symbol,
                 },
-            ) => context.lookup(symbol_name, *offset_from_symbol, &mut path_mapper),
+            ) => context.lookup(symbol_name, *offset_from_symbol),
             (
                 ExternalFileMemberContexts::Archive {
                     member_ranges,
@@ -175,18 +171,12 @@ impl<F: FileContents> ExternalFileInnerTrait for ExternalFileInner<'_, F> {
             ) => {
                 let mut member_contexts = contexts.lock().unwrap();
                 match member_contexts.get(name_in_archive) {
-                    Some(member_context) => {
-                        member_context.lookup(symbol_name, *offset_from_symbol, &mut path_mapper)
-                    }
+                    Some(member_context) => member_context.lookup(symbol_name, *offset_from_symbol),
                     None => {
                         let range = *member_ranges.get(name_in_archive.as_bytes())?;
                         // .ok_or_else(|| Error::FileNotInArchive(name_in_archive.to_owned()))?;
                         let member_context = self.external_file.make_member_context(range).ok()?;
-                        let res = member_context.lookup(
-                            symbol_name,
-                            *offset_from_symbol,
-                            &mut path_mapper,
-                        );
+                        let res = member_context.lookup(symbol_name, *offset_from_symbol);
                         member_contexts.insert(name_in_archive.to_string(), member_context);
                         res
                     }
@@ -215,11 +205,10 @@ impl ExternalFileMemberContext<'_> {
         &self,
         symbol_name: &[u8],
         offset_from_symbol: u32,
-        path_mapper: &mut PathMapper<()>,
     ) -> Option<Vec<FrameDebugInfo>> {
         let symbol_address = self.symbol_addresses.get(symbol_name)?;
         let address = symbol_address + offset_from_symbol as u64;
-        get_frames(address, self.context.as_ref(), path_mapper)
+        get_frames(address, self.context.as_ref())
     }
 }
 

samply-symbols/src/lib.rs

@@ -229,7 +229,6 @@ mod external_file;
 mod jitdump;
 mod macho;
 mod mapped_path;
-mod path_mapper;
 mod shared;
 mod symbol_map;
 mod symbol_map_object;

samply-symbols/src/path_mapper.rs

@@ -13,7 +13,6 @@ use yoke::Yoke;
 use yoke_derive::Yokeable;
 
 use crate::dwarf::convert_frames;
-use crate::path_mapper::PathMapper;
 use crate::shared::{
     relative_address_base, ExternalFileAddressInFileRef, ExternalFileAddressRef, ExternalFileRef,
     FramesLookupResult, LookupAddress, SymbolInfo,
@@ -353,7 +352,6 @@ impl std::fmt::Debug for SvmaFileRange {
 pub struct ObjectSymbolMapInner<'a, Symbol, FC: FileContents + 'static, DDM> {
     list: SymbolList<'a, Symbol>,
     debug_id: DebugId,
-    path_mapper: Mutex<PathMapper<()>>,
     object_map: ObjectMap<'a>,
     context: Option<Mutex<addr2line::Context<gimli::EndianSlice<'a, gimli::RunTimeEndian>>>>,
     dwp_package:
@@ -480,9 +478,7 @@ where
                             continue;
                         }
                         LookupResult::Output(Ok(frame_iter)) => {
-                            let mut path_mapper = self.path_mapper.lock().unwrap();
-                            convert_frames(frame_iter, &mut path_mapper)
-                                .map(FramesLookupResult::Available)
+                            convert_frames(frame_iter).map(FramesLookupResult::Available)
                         }
                         LookupResult::Output(Err(_)) => None,
                     };
@@ -564,9 +560,7 @@ where
                         ))
                     }
                     LookupResult::Output(Ok(frame_iter)) => {
-                        let mut path_mapper = self.path_mapper.lock().unwrap();
-                        convert_frames(frame_iter, &mut path_mapper)
-                            .map(FramesLookupResult::Available)
+                        convert_frames(frame_iter).map(FramesLookupResult::Available)
                     }
                     LookupResult::Output(Err(_)) => {
                         drop(lookup_result);
@@ -677,7 +671,6 @@ impl<'a, FC: FileContents + 'static> ObjectSymbolMapInnerWrapper<'a, FC> {
         let inner = ObjectSymbolMapInner {
             list,
             debug_id,
-            path_mapper: Mutex::new(PathMapper::new()),
             object_map: object_file.object_map(),
             context: addr2line_context.map(Mutex::new),
             dwp_package,

samply-symbols/src/symbol_map_object.rs

@@ -14,7 +14,6 @@ use crate::debugid_util::debug_id_for_object;
 use crate::dwarf::Addr2lineContextData;
 use crate::error::{Context, Error};
 use crate::mapped_path::UnparsedMappedPath;
-use crate::path_mapper::{ExtraPathMapper, PathMapper};
 use crate::shared::{
     FileAndPathHelper, FileContents, FileContentsWrapper, FileLocation, FrameDebugInfo,
     FramesLookupResult, LookupAddress, SourceFilePath, SymbolInfo,
@@ -181,7 +180,6 @@ impl<FC: FileContents + 'static> PdbObjectTrait for PdbObject<'_, FC> {
             )?)),
             None => None,
         };
-        let path_mapper = PathMapper::new_with_maybe_extra_mapper(path_mapper);
 
         let symbol_map = PdbSymbolMapInner {
             context,
@@ -233,7 +231,7 @@ pub struct PdbSymbolMapInnerWrapper<'data>(Box<dyn SymbolMapTrait + Send + 'data
 struct PdbSymbolMapInner<'object> {
     context: Box<dyn PdbAddr2lineContextTrait + Send + 'object>,
     debug_id: DebugId,
-    path_mapper: Mutex<PathMapper<SrcSrvPathMapper<'object>>>,
+    path_mapper: Mutex<Option<SrcSrvPathMapper<'object>>>,
 }
 
 impl SymbolMapTrait for PdbSymbolMapInner<'_> {
@@ -288,16 +286,12 @@ impl SymbolMapTrait for PdbSymbolMapInner<'_> {
         let frames = if has_debug_info(&function_frames) {
             let mut path_mapper = self.path_mapper.lock().unwrap();
             let mut map_path = |path: Cow<str>| {
-                let mapped_path = path_mapper.map_path(&path);
-                match mapped_path {
-                    UnparsedMappedPath::Url(url) => {
-                        SourceFilePath::RawPathAndUrl(path.into_owned(), url)
+                if let Some(path_mapper) = &mut *path_mapper {
+                    if let Some(UnparsedMappedPath::Url(url)) = path_mapper.map_path(&path) {
+                        return SourceFilePath::RawPathAndUrl(path.into_owned(), url);
                     }
-                    UnparsedMappedPath::BreakpadSpecialPath(_) => unreachable!(
-                        "path_mapper should never UnparsedMappedPath::BreakpadSpecialPath"
-                    ),
-                    UnparsedMappedPath::RawPath(_) => SourceFilePath::RawPath(path.into_owned()),
                 }
+                SourceFilePath::RawPath(path.into_owned())
             };
             let frames: Vec<_> = function_frames
                 .frames
@@ -441,7 +435,7 @@ struct SrcSrvPathMapper<'a> {
     command_is_file_download_with_url_in_var4_and_uncompress_function_in_var5: bool,
 }
 
-impl ExtraPathMapper for SrcSrvPathMapper<'_> {
+impl<'a> SrcSrvPathMapper<'a> {
     fn map_path(&mut self, path: &str) -> Option<UnparsedMappedPath> {
         if let Some(value) = self.cache.get(path) {
             return value.clone();
@@ -464,9 +458,7 @@ impl ExtraPathMapper for SrcSrvPathMapper<'_> {
         self.cache.insert(path.to_string(), value.clone());
         value
     }
-}
 
-impl<'a> SrcSrvPathMapper<'a> {
     pub fn new(srcsrv_stream: srcsrv::SrcSrvStream<'a>) -> Self {
         let command_is_file_download_with_url_in_var4_and_uncompress_function_in_var5 =
             Self::matches_chrome_gitiles_workaround(&srcsrv_stream);