The Tor Browser: toolkit/crashreporter/google-breakpad/src/client/ios/BreakpadController.mm@6474c204b198 (annotated)

toolkit/crashreporter/google-breakpad/src/client/ios/BreakpadController.mm@6474c204b198 (annotated)

toolkit/crashreporter/google-breakpad/src/client/ios/BreakpadController.mm

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 // Copyright (c) 2012, 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
 // copyright notice, this list of conditions and the following disclaimer
 // in the documentation and/or other materials provided with the
 // distribution.
 //     * Neither the name of Google Inc. nor the names of its
 // contributors may be used to endorse or promote products derived from
 // this software without specific prior written permission.
 //
 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 // 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.
 #import "BreakpadController.h"
 #import <UIKit/UIKit.h>
 #include <asl.h>
 #include <execinfo.h>
 #include <signal.h>
 #include <unistd.h>
 #include <sys/sysctl.h>
 #include <common/scoped_ptr.h>
 #pragma mark -
 #pragma mark Private Methods
 @interface BreakpadController ()
 // Init the singleton instance.
 - (id)initSingleton;
 // Load a crash report and send it to the server.
 - (void)sendStoredCrashReports;
 // Returns when a report can be sent. |-1| means never, |0| means that a report
 // can be sent immediately, a positive number is the number of seconds to wait
 // before being allowed to upload a report.
 - (int)sendDelay;
 // Notifies that a report will be sent, and update the last sending time
 // accordingly.
 - (void)reportWillBeSent;
 @end
 #pragma mark -
 #pragma mark Anonymous namespace
 namespace {
 // The name of the user defaults key for the last submission to the crash
 // server.
 NSString* const kLastSubmission = @"com.google.Breakpad.LastSubmission";
 // Returns a NSString describing the current platform.
 NSString* GetPlatform() {
   // Name of the system call for getting the platform.
   static const char kHwMachineSysctlName[] = "hw.machine";
   NSString* result = nil;
   size_t size = 0;
   if (sysctlbyname(kHwMachineSysctlName, NULL, &size, NULL, 0) || size == 0)
     return nil;
   google_breakpad::scoped_array<char> machine(new char[size]);
   if (sysctlbyname(kHwMachineSysctlName, machine.get(), &size, NULL, 0) == 0)
     result = [NSString stringWithUTF8String:machine.get()];
   return result;
 }
 }  // namespace
 #pragma mark -
 #pragma mark BreakpadController Implementation
 @implementation BreakpadController
 + (BreakpadController*)sharedInstance {
   @synchronized(self) {
     static BreakpadController* sharedInstance_ =
         [[BreakpadController alloc] initSingleton];
     return sharedInstance_;
   }
 }
 - (id)init {
   return nil;
 }
 - (id)initSingleton {
   self = [super init];
   if (self) {
     queue_ = dispatch_queue_create("com.google.BreakpadQueue", NULL);
     configuration_ = [[[NSBundle mainBundle] infoDictionary] mutableCopy];
     enableUploads_ = NO;
     started_ = NO;
     NSString* uploadInterval =
         [configuration_ valueForKey:@BREAKPAD_REPORT_INTERVAL];
     [self setUploadInterval:[uploadInterval intValue]];
   }
   return self;
 }
 // Since this class is a singleton, this method is not expected to be called.
 - (void)dealloc {
   assert(!breakpadRef_);
   dispatch_release(queue_);
   [configuration_ release];
   [super dealloc];
 }
 #pragma mark -
 - (void)start:(BOOL)onCurrentThread {
   if (started_)
     return;
   started_ = YES;
   void(^startBlock)() = ^{
       assert(!breakpadRef_);
       breakpadRef_ = BreakpadCreate(configuration_);
       if (breakpadRef_) {
         BreakpadAddUploadParameter(breakpadRef_, @"platform", GetPlatform());
       }
   };
   if (onCurrentThread)
     startBlock();
   else
     dispatch_async(queue_, startBlock);
 }
 - (void)stop {
   if (!started_)
     return;
   started_ = NO;
   dispatch_sync(queue_, ^{
       if (breakpadRef_) {
         BreakpadRelease(breakpadRef_);
         breakpadRef_ = NULL;
       }
   });
 }
 - (void)setUploadingEnabled:(BOOL)enabled {
   NSAssert(started_,
       @"The controller must be started before setUploadingEnabled is called");
   dispatch_async(queue_, ^{
       if (enabled == enableUploads_)
         return;
       if (enabled) {
         // Set this before calling doSendStoredCrashReport, because that
         // calls sendDelay, which in turn checks this flag.
         enableUploads_ = YES;
         [self sendStoredCrashReports];
       } else {
         enableUploads_ = NO;
         [NSObject cancelPreviousPerformRequestsWithTarget:self
             selector:@selector(sendStoredCrashReports)
             object:nil];
       }
   });
 }
 - (void)updateConfiguration:(NSDictionary*)configuration {
   NSAssert(!started_,
       @"The controller must not be started when updateConfiguration is called");
   [configuration_ addEntriesFromDictionary:configuration];
   NSString* uploadInterval =
       [configuration_ valueForKey:@BREAKPAD_REPORT_INTERVAL];
   if (uploadInterval)
     [self setUploadInterval:[uploadInterval intValue]];
 }
 - (void)setUploadingURL:(NSString*)url {
   NSAssert(!started_,
       @"The controller must not be started when setUploadingURL is called");
   [configuration_ setValue:url forKey:@BREAKPAD_URL];
 }
 - (void)setUploadInterval:(int)intervalInSeconds {
   NSAssert(!started_,
       @"The controller must not be started when setUploadInterval is called");
   [configuration_ removeObjectForKey:@BREAKPAD_REPORT_INTERVAL];
   uploadIntervalInSeconds_ = intervalInSeconds;
   if (uploadIntervalInSeconds_ < 0)
     uploadIntervalInSeconds_ = 0;
 }
 - (void)addUploadParameter:(NSString*)value forKey:(NSString*)key {
   NSAssert(started_,
       @"The controller must be started before addUploadParameter is called");
   dispatch_async(queue_, ^{
       if (breakpadRef_)
         BreakpadAddUploadParameter(breakpadRef_, key, value);
   });
 }
 - (void)removeUploadParameterForKey:(NSString*)key {
   NSAssert(started_, @"The controller must be started before "
                      "removeUploadParameterForKey is called");
   dispatch_async(queue_, ^{
       if (breakpadRef_)
         BreakpadRemoveUploadParameter(breakpadRef_, key);
   });
 }
 - (void)withBreakpadRef:(void(^)(BreakpadRef))callback {
   NSAssert(started_,
       @"The controller must be started before withBreakpadRef is called");
   dispatch_async(queue_, ^{
       callback(breakpadRef_);
   });
 }
 - (void)hasReportToUpload:(void(^)(BOOL))callback {
   NSAssert(started_, @"The controller must be started before "
                      "hasReportToUpload is called");
   dispatch_async(queue_, ^{
       callback(breakpadRef_ && BreakpadHasCrashReportToUpload(breakpadRef_));
   });
 }
 #pragma mark -
 - (int)sendDelay {
   if (!breakpadRef_ || uploadIntervalInSeconds_ <= 0 || !enableUploads_)
     return -1;
   // To prevent overloading the crash server, crashes are not sent than one
   // report every |uploadIntervalInSeconds_|. A value in the user defaults is
   // used to keep the time of the last upload.
   NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
   NSNumber *lastTimeNum = [userDefaults objectForKey:kLastSubmission];
   NSTimeInterval lastTime = lastTimeNum ? [lastTimeNum floatValue] : 0;
   NSTimeInterval spanSeconds = CFAbsoluteTimeGetCurrent() - lastTime;
   if (spanSeconds >= uploadIntervalInSeconds_)
     return 0;
   return uploadIntervalInSeconds_ - static_cast<int>(spanSeconds);
 }
 - (void)reportWillBeSent {
   NSUserDefaults *userDefaults = [NSUserDefaults standardUserDefaults];
   [userDefaults setObject:[NSNumber numberWithDouble:CFAbsoluteTimeGetCurrent()]
                    forKey:kLastSubmission];
   [userDefaults synchronize];
 }
 - (void)sendStoredCrashReports {
   dispatch_async(queue_, ^{
       if (!BreakpadHasCrashReportToUpload(breakpadRef_))
         return;
       int timeToWait = [self sendDelay];
       // Unable to ever send report.
       if (timeToWait == -1)
         return;
       // A report can be sent now.
       if (timeToWait == 0) {
         [self reportWillBeSent];
         BreakpadUploadNextReport(breakpadRef_);
         // If more reports must be sent, make sure this method is called again.
         if (BreakpadHasCrashReportToUpload(breakpadRef_))
           timeToWait = uploadIntervalInSeconds_;
       }
       // A report must be sent later.
       if (timeToWait > 0)
         [self performSelector:@selector(sendStoredCrashReports)
                    withObject:nil
                    afterDelay:timeToWait];
   });
 }
 @end

The Tor Browser / annotate

toolkit/crashreporter/google-breakpad/src/client/ios/BreakpadController.mm@6474c204b198 (annotated)

toolkit/crashreporter/google-breakpad/src/client/ios/BreakpadController.mm