unittests: fix -Wnarrowing build errors

src/common/dwarf_cu_to_module_unittest.cc

 // 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
 // notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
@@ skipping 13 matching lines @@
 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // Original author: Jim Blandy <jimb@mozilla.com> <jimb@red-bean.com>
 
 // dwarf_cu_to_module.cc: Unit tests for google_breakpad::DwarfCUToModule.
 
+#include <stdint.h>
+
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "breakpad_googletest_includes.h"
 #include "common/dwarf_cu_to_module.h"
 #include "common/using_std_string.h"
 
 using std::make_pair;
 using std::vector;
@@ skipping 14 matching lines @@
 using ::testing::Test;
 using ::testing::TestWithParam;
 using ::testing::Values;
 using ::testing::ValuesIn;
 
 // Mock classes.
 
 class MockLineToModuleHandler: public DwarfCUToModule::LineToModuleHandler {
  public:
   MOCK_METHOD1(StartCompilationUnit, void(const string& compilation_dir));
-  MOCK_METHOD4(ReadProgram, void(const char* program, uint64 length,
+  MOCK_METHOD4(ReadProgram, void(const uint8_t *program, uint64 length,
                                  Module *module, vector<Module::Line> *lines));
 };
 
 class MockWarningReporter: public DwarfCUToModule::WarningReporter {
  public:
   MockWarningReporter(const string &filename, uint64 cu_offset)
       : DwarfCUToModule::WarningReporter(filename, cu_offset) { }
   MOCK_METHOD1(SetCUName, void(const string &name));
   MOCK_METHOD2(UnknownSpecification, void(uint64 offset, uint64 target));
   MOCK_METHOD2(UnknownAbstractOrigin, void(uint64 offset, uint64 target));
@@ skipping 25 matching lines @@
   //
   //   MockLineToModuleHandler l2m;
   //   EXPECT_CALL(l2m, ReadProgram(_,_,_,_))
   //       .WillOnce(DoAll(Invoke(appender), Return()));
   //
   // in which case calling l2m with some line vector will append lines.
   class AppendLinesFunctor {
    public:
     explicit AppendLinesFunctor(
         const vector<Module::Line> *lines) : lines_(lines) { }
-    void operator()(const char *program, uint64 length,
+    void operator()(const uint8_t *program, uint64 length,
                     Module *module, vector<Module::Line> *lines) {
       lines->insert(lines->end(), lines_->begin(), lines_->end());
     }
    private:
     const vector<Module::Line> *lines_;
   };
 
   CUFixtureBase()
       : module_("module-name", "module-os", "module-arch", "module-id"),
         file_context_("dwarf-filename", &module_, true),
@@ skipping 153 matching lines @@
   string compilation_dir_;
 
   // If this is not empty, we'll give the CU a DW_AT_stmt_list
   // attribute that, when passed to line_reader_, adds these lines to the
   // provided lines array.
   vector<Module::Line> lines_;
 
   // Mock line program reader.
   MockLineToModuleHandler line_reader_;
   AppendLinesFunctor appender_;
-  static const char dummy_line_program_[];
+  static const uint8_t dummy_line_program_[];
   static const size_t dummy_line_size_;
 
   MockWarningReporter reporter_;
   DwarfCUToModule root_handler_;
 
  private:
   // Fill functions_, if we haven't already.
   void FillFunctions();
 
   // If functions_filled_ is true, this is a table of functions we've
   // extracted from module_, sorted by address.
   vector<Module::Function *> functions_;
   // True if we have filled the above vector with this.module_'s function list.
   bool functions_filled_;
 };
 
-const char CUFixtureBase::dummy_line_program_[] = "lots of fun data";
+const uint8_t CUFixtureBase::dummy_line_program_[] = "lots of fun data";
 const size_t CUFixtureBase::dummy_line_size_ =
     sizeof(CUFixtureBase::dummy_line_program_);
 
 void CUFixtureBase::PushLine(Module::Address address, Module::Address size,
                              const string &filename, int line_number) {
   Module::Line l;
   l.address = address;
   l.size = size;
   l.file = module_.FindFile(filename);
   l.number = line_number;
@@ skipping 52 matching lines @@
     dwarf2reader::DIEHandler *handler) {
   handler->ProcessAttributeUnsigned((DwarfAttribute) 0xf560dead,
                                     (DwarfForm) 0x4106e4db,
                                     0xa592571997facda1ULL);
   handler->ProcessAttributeSigned((DwarfAttribute) 0x85380095,
                                   (DwarfForm) 0x0f16fe87,
                                   0x12602a4e3bf1f446LL);
   handler->ProcessAttributeReference((DwarfAttribute) 0xf7f7480f,
                                      (DwarfForm) 0x829e038a,
                                      0x50fddef44734fdecULL);
-  static const char buffer[10] = "frobynode";
+  static const uint8_t buffer[10] = "frobynode";
   handler->ProcessAttributeBuffer((DwarfAttribute) 0xa55ffb51,
                                   (DwarfForm) 0x2f43b041,
                                   buffer, sizeof(buffer));
   handler->ProcessAttributeString((DwarfAttribute) 0x2f43b041,
                                   (DwarfForm) 0x895ffa23,
                                   "strange string");
 }
 
 DIEHandler *CUFixtureBase::StartNamedDIE(DIEHandler *parent,
                                          DwarfTag tag,
@@ skipping 1381 matching lines @@
   reporter.UncoveredLine(line);
   EXPECT_TRUE(reporter.uncovered_warnings_enabled());
 }
 
 TEST_F(Reporter, UnnamedFunction) {
   reporter.UnnamedFunction(0x90c0baff9dedb2d9ULL);
 }
 
 // Would be nice to also test:
 // - overlapping lines, functions