Refactor the logic of resolving source line info into helper class

src/processor/stackwalker_x86.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 63 matching lines @@
   { "$esi", NULL,   true,
     StackFrameX86::CONTEXT_VALID_ESI, &MDRawContextX86::esi },
   { "$edi", NULL,   true,
     StackFrameX86::CONTEXT_VALID_EDI, &MDRawContextX86::edi },
 };
 
 StackwalkerX86::StackwalkerX86(const SystemInfo *system_info,
                                const MDRawContextX86 *context,
                                MemoryRegion *memory,
                                const CodeModules *modules,
-                               SymbolSupplier *supplier,
-                               SourceLineResolverInterface *resolver)
-    : Stackwalker(system_info, memory, modules, supplier, resolver),
+                               StackFrameSymbolizer *resolver_helper)

[Ted Mielczarek, 2012/10/09 12:30:54]

* next to type name.

[SiyangXie, 2012/10/10 20:28:43]

Done.

+    : Stackwalker(system_info, memory, modules, resolver_helper),
       context_(context),
       cfi_walker_(cfi_register_map_,
                   (sizeof(cfi_register_map_) / sizeof(cfi_register_map_[0]))) {
   if (memory_->GetBase() + memory_->GetSize() - 1 > 0xffffffff) {
     // The x86 is a 32-bit CPU, the limits of the supplied stack are invalid.
     // Mark memory_ = NULL, which will cause stackwalking to fail.
     BPLOG(ERROR) << "Memory out of range for stackwalking: " <<
                     HexString(memory_->GetBase()) << "+" <<
                     HexString(memory_->GetSize());
     memory_ = NULL;
@@ skipping 454 matching lines @@
     BPLOG(ERROR) << "Can't get caller frame without memory or stack";
     return NULL;
   }
 
   const vector<StackFrame *> &frames = *stack->frames();
   StackFrameX86 *last_frame = static_cast<StackFrameX86 *>(frames.back());
   scoped_ptr<StackFrameX86> new_frame;
 
   // If the resolver has Windows stack walking information, use that.
   WindowsFrameInfo *windows_frame_info
-      = resolver_ ? resolver_->FindWindowsFrameInfo(last_frame) : NULL;
+      = frame_symbolizer_->FindWindowsFrameInfo(last_frame);
   if (windows_frame_info)
     new_frame.reset(GetCallerByWindowsFrameInfo(frames, windows_frame_info));
 
   // If the resolver has DWARF CFI information, use that.
   if (!new_frame.get()) {
     CFIFrameInfo *cfi_frame_info = 
-        resolver_ ? resolver_->FindCFIFrameInfo(last_frame) : NULL;
+        frame_symbolizer_->FindCFIFrameInfo(last_frame);
     if (cfi_frame_info)
       new_frame.reset(GetCallerByCFIFrameInfo(frames, cfi_frame_info));
   }
 
   // Otherwise, hope that the program was using a traditional frame structure.
   if (!new_frame.get())
     new_frame.reset(GetCallerByEBPAtBase(frames));
 
   // If nothing worked, tell the caller.
   if (!new_frame.get())
@@ skipping 16 matching lines @@
   // the CALL, which is sufficient to get the source line information to
   // match up with the line that contains a function call. Callers that
   // require the exact return address value may access the context.eip
   // field of StackFrameX86.
   new_frame->instruction = new_frame->context.eip - 1;
 
   return new_frame.release();
 }
 
 }  // namespace google_breakpad