Server-side workaround to handle overlapping modules.

src/processor/stackwalker_unittest_utils.h

 // -*- mode: C++ -*-
 
 // Copyright (c) 2010, Google Inc.
 // All rights reserved.
 //
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
@@ skipping 30 matching lines @@
 #include <string>
 #include <vector>
 
 #include "common/using_std_string.h"
 #include "google_breakpad/common/breakpad_types.h"
 #include "google_breakpad/processor/code_module.h"
 #include "google_breakpad/processor/code_modules.h"
 #include "google_breakpad/processor/memory_region.h"
 #include "google_breakpad/processor/symbol_supplier.h"
 #include "google_breakpad/processor/system_info.h"
+#include "processor/linked_ptr.h"
 
 class MockMemoryRegion: public google_breakpad::MemoryRegion {
  public:
   MockMemoryRegion(): base_address_(0) { }
 
   // Set this region's address and contents. If we have placed an
   // instance of this class in a test fixture class, individual tests
   // can use this to provide the region's contents.
   void Init(uint64_t base_address, const string &contents) {
     base_address_ = base_address;
@@ skipping 46 matching lines @@
                  const string &code_file, const string &version)
       : base_address_(base_address), size_(size), code_file_(code_file) { }
 
   uint64_t base_address()       const { return base_address_; }
   uint64_t size()               const { return size_; }
   string code_file()        const { return code_file_; }
   string code_identifier()  const { return code_file_; }
   string debug_file()       const { return code_file_; }
   string debug_identifier() const { return code_file_; }
   string version()          const { return version_; }
-  const google_breakpad::CodeModule *Copy() const {
+  google_breakpad::CodeModule *Copy() const {
     abort(); // Tests won't use this.
   }
+  virtual uint64_t shrink_down_delta() const { return 0; }
+  virtual void SetShrinkDownDelta(uint64_t shrink_down_delta) {}
 
  private:
   uint64_t base_address_;
   uint64_t size_;
   string code_file_;
   string version_;
 };
 
 class MockCodeModules: public google_breakpad::CodeModules {
- public:  
+ public:
   typedef google_breakpad::CodeModule CodeModule;
   typedef google_breakpad::CodeModules CodeModules;
 
-  void Add(const MockCodeModule *module) { 
+  void Add(const MockCodeModule *module) {
     modules_.push_back(module);
   }
 
   unsigned int module_count() const { return modules_.size(); }
 
   const CodeModule *GetModuleForAddress(uint64_t address) const {
     for (ModuleVector::const_iterator i = modules_.begin();
          i != modules_.end(); i++) {
       const MockCodeModule *module = *i;
       if (module->base_address() <= address &&
           address - module->base_address() < module->size())
         return module;
     }
     return NULL;
   };
 
   const CodeModule *GetMainModule() const { return modules_[0]; }
 
   const CodeModule *GetModuleAtSequence(unsigned int sequence) const {
     return modules_.at(sequence);
   }
 
   const CodeModule *GetModuleAtIndex(unsigned int index) const {
     return modules_.at(index);
   }
 
-  const CodeModules *Copy() const { abort(); } // Tests won't use this.
+  CodeModules *Copy() const { abort(); }  // Tests won't use this
 
- private:  
+  virtual std::vector<google_breakpad::linked_ptr<const CodeModule> >
+  GetShrunkRangeModules() const {
+    return std::vector<google_breakpad::linked_ptr<const CodeModule> >();
+  }
+
+  // Returns true, if module address range shrink is enabled.
+  bool IsModuleShrinkEnabled() const {
+    return false;
+  }
+
+ private:
   typedef std::vector<const MockCodeModule *> ModuleVector;
   ModuleVector modules_;
 };
 
 class MockSymbolSupplier: public google_breakpad::SymbolSupplier {
  public:
   typedef google_breakpad::CodeModule CodeModule;
   typedef google_breakpad::SystemInfo SystemInfo;
   MOCK_METHOD3(GetSymbolFile, SymbolResult(const CodeModule *module,
                                            const SystemInfo *system_info,
@@ skipping 29 matching lines @@
     }
   }
 
  private:
   // List of symbol data to be freed upon destruction
   typedef std::vector<char*> SymbolDataVector;
   SymbolDataVector symbol_data_to_free_;
 };
 
 #endif // PROCESSOR_STACKWALKER_UNITTEST_UTILS_H_