Merge googledatatransport to master

.travis.yml

@@ -124,6 +124,26 @@ jobs:
         # The travis_wait is necessary because the command takes more than 10 minutes.
         - travis_wait 45 ./scripts/pod_lib_lint.sh FirebaseFirestore.podspec --use-libraries --allow-warnings --no-subspecs
 
+    # GoogleDataTransport unit tests and pod linting using the default Xcode version.
+    - stage: test
+      env:
+        - PROJECT=GoogleDataTransport PLATFORM=iOS METHOD=xcodebuild
+      before_install:
+        - ./scripts/if_changed.sh ./scripts/install_prereqs.sh
+      script:
+        - travis_retry ./scripts/if_changed.sh ./scripts/build.sh $PROJECT $PLATFORM
+        - travis_retry ./scripts/if_changed.sh ./scripts/pod_lib_lint.sh GoogleDataTransport.podspec
+
+    # GoogleDataTransportCCTSupport unit tests and pod linting using the default Xcode version.
+    - stage: test
+      env:
+        - PROJECT=GoogleDataTransportCCTSupport PLATFORM=iOS METHOD=xcodebuild
+      before_install:
+        - ./scripts/if_changed.sh ./scripts/install_prereqs.sh
+      script:
+        - ./scripts/if_changed.sh ./scripts/build.sh $PROJECT $PLATFORM
+        - ./scripts/if_changed.sh ./scripts/pod_lib_lint.sh GoogleDataTransportCCTSupport.podspec
+
     # Daily test for symbol collisions between Firebase and CocoaPods.
     - stage: test
       if: type = cron

GoogleDataTransport.podspec

@@ -0,0 +1,55 @@
+Pod::Spec.new do |s|
+  s.name             = 'GoogleDataTransport'
+  s.version          = '0.1.0'
+  s.summary          = 'Google iOS SDK data transport.'
+
+  s.description      = <<-DESC
+Shared library for iOS SDK data transport needs.
+                       DESC
+
+  s.homepage         = 'https://developers.google.com/'
+  s.license          = { :type => 'Apache', :file => 'LICENSE' }
+  s.authors          = 'Google, Inc.'
+  s.source           = {
+    :git => 'https://github.com/firebase/firebase-ios-sdk.git',
+    :tag => 'GoogleDataTransport-' + s.version.to_s
+  }
+
+  s.ios.deployment_target = '8.0'
+
+  # To develop or run the tests, >= 1.6.0 must be installed.
+  s.cocoapods_version = '>= 1.4.0'
+
+  s.static_framework = true
+  s.prefix_header_file = false
+
+  s.source_files = 'GoogleDataTransport/GoogleDataTransport/**/*'
+  s.public_header_files = 'GoogleDataTransport/GoogleDataTransport/Classes/Public/*.h'
+  s.private_header_files = 'GoogleDataTransport/GoogleDataTransport/Classes/Private/*.h'
+
+  s.pod_target_xcconfig = {
+    'GCC_C_LANGUAGE_STANDARD' => 'c99',
+    'GCC_TREAT_WARNINGS_AS_ERRORS' => 'YES',
+    'CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY' => 'YES'
+  }
+
+  common_test_sources = ['GoogleDataTransport/Tests/Common/**/*.{h,m}']
+
+  # Unit test specs
+  s.test_spec 'Tests-Unit' do |test_spec|
+    test_spec.requires_app_host = false
+    test_spec.source_files = ['GoogleDataTransport/Tests/Unit/**/*.{h,m}'] + common_test_sources
+  end
+
+  s.test_spec 'Tests-Lifecycle' do |test_spec|
+    test_spec.requires_app_host = false
+    test_spec.source_files = ['GoogleDataTransport/Tests/Lifecycle/**/*.{h,m}'] + common_test_sources
+  end
+
+  # Integration test specs
+  s.test_spec 'Tests-Integration' do |test_spec|
+    test_spec.requires_app_host = false
+    test_spec.source_files = ['GoogleDataTransport/Tests/Integration/**/*.{h,m}'] + common_test_sources
+    test_spec.dependency 'GCDWebServer'
+  end
+end

GoogleDataTransport/GoogleDataTransport/Classes/GDTAssert.m

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2019 Google
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "GDTAssert.h"
+
+GDTAssertionBlock GDTAssertionBlockToRunInsteadOfNSAssert(void) {
+  // This class is only compiled in by unit tests, and this should fail quickly in optimized builds.
+  Class GDTAssertClass = NSClassFromString(@"GDTAssertHelper");
+  if (__builtin_expect(!!GDTAssertClass, 0)) {
+    SEL assertionBlockSEL = NSSelectorFromString(@"assertionBlock");
+    if (assertionBlockSEL) {
+      IMP assertionBlockIMP = [GDTAssertClass methodForSelector:assertionBlockSEL];
+      if (assertionBlockIMP) {
+        GDTAssertionBlock assertionBlock =
+            ((GDTAssertionBlock(*)(id, SEL))assertionBlockIMP)(GDTAssertClass, assertionBlockSEL);
+        if (assertionBlock) {
+          return assertionBlock;
+        }
+      }
+    }
+  }
+  return NULL;
+}

GoogleDataTransport/GoogleDataTransport/Classes/GDTClock.m

@@ -0,0 +1,162 @@
+/*
+ * Copyright 2018 Google
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "GDTClock.h"
+
+#import <sys/sysctl.h>
+
+// Using a monotonic clock is necessary because CFAbsoluteTimeGetCurrent(), NSDate, and related all
+// are subject to drift. That it to say, multiple consecutive calls do not always result in a
+// time that is in the future. Clocks may be adjusted by the user, NTP, or any number of external
+// factors. This class attempts to determine the wall-clock time at the time of the event by
+// capturing the kernel start and time since boot to determine a wallclock time in UTC.
+//
+// Timezone offsets at the time of a snapshot are also captured in order to provide local-time
+// details. Other classes in this library depend on comparing times at some time in the future to
+// a time captured in the past, and this class needs to provide a mechanism to do that.
+//
+// TL;DR: This class attempts to accomplish two things: 1. Provide accurate event times. 2. Provide
+// a monotonic clock mechanism to accurately check if some clock snapshot was before or after
+// by using a shared reference point (kernel boot time).
+//
+// Note: Much of the mach time stuff doesn't work properly in the simulator. So this class can be
+// difficult to unit test.
+
+/** Returns the kernel boottime property from sysctl.
+ *
+ * Inspired by https://stackoverflow.com/a/40497811
+ *
+ * @return The KERN_BOOTTIME property from sysctl, in nanoseconds.
+ */
+static int64_t KernelBootTimeInNanoseconds() {
+  // Caching the result is not possible because clock drift would not be accounted for.
+  struct timeval boottime;
+  int mib[2] = {CTL_KERN, KERN_BOOTTIME};
+  size_t size = sizeof(boottime);
+  int rc = sysctl(mib, 2, &boottime, &size, NULL, 0);
+  if (rc != 0) {
+    return 0;
+  }
+  return (int64_t)boottime.tv_sec * NSEC_PER_MSEC + (int64_t)boottime.tv_usec;
+}
+
+/** Returns value of gettimeofday, in nanoseconds.
+ *
+ * Inspired by https://stackoverflow.com/a/40497811
+ *
+ * @return The value of gettimeofday, in nanoseconds.
+ */
+static int64_t UptimeInNanoseconds() {
+  int64_t before_now;
+  int64_t after_now;
+  struct timeval now;
+
+  before_now = KernelBootTimeInNanoseconds();
+  // Addresses a race condition in which the system time has updated, but the boottime has not.
+  do {
+    gettimeofday(&now, NULL);
+    after_now = KernelBootTimeInNanoseconds();
+  } while (after_now != before_now);
+  return (int64_t)now.tv_sec * NSEC_PER_MSEC + (int64_t)now.tv_usec - before_now;
+}
+
+// TODO: Consider adding a 'trustedTime' property that can be populated by the response from a BE.
+@implementation GDTClock
+
+- (instancetype)init {
+  self = [super init];
+  if (self) {
+    _kernelBootTime = KernelBootTimeInNanoseconds();
+    _uptime = UptimeInNanoseconds();
+    _timeMillis =
+        (int64_t)((CFAbsoluteTimeGetCurrent() + kCFAbsoluteTimeIntervalSince1970) * NSEC_PER_USEC);
+    CFTimeZoneRef timeZoneRef = CFTimeZoneCopySystem();
+    _timezoneOffsetSeconds = CFTimeZoneGetSecondsFromGMT(timeZoneRef, 0);
+    CFRelease(timeZoneRef);
+  }
+  return self;
+}
+
++ (GDTClock *)snapshot {
+  return [[GDTClock alloc] init];
+}
+
++ (instancetype)clockSnapshotInTheFuture:(uint64_t)millisInTheFuture {
+  GDTClock *snapshot = [self snapshot];
+  snapshot->_timeMillis += millisInTheFuture;
+  return snapshot;
+}
+
+- (BOOL)isAfter:(GDTClock *)otherClock {
+  // These clocks are trivially comparable when they share a kernel boot time.
+  if (_kernelBootTime == otherClock->_kernelBootTime) {
+    return _uptime > otherClock->_uptime;
+  } else {
+    int64_t kernelBootTimeDiff = otherClock->_kernelBootTime - _kernelBootTime;
+    // This isn't a great solution, but essentially, if the other clock's boot time is 'later', NO
+    // is returned. This can be altered by changing the system time and rebooting.
+    return kernelBootTimeDiff < 0 ? YES : NO;
+  }
+}
+
+- (NSUInteger)hash {
+  return [@(_kernelBootTime) hash] ^ [@(_uptime) hash] ^ [@(_timeMillis) hash] ^
+         [@(_timezoneOffsetSeconds) hash];
+}
+
+- (BOOL)isEqual:(id)object {
+  return [self hash] == [object hash];
+}
+
+#pragma mark - NSSecureCoding
+
+/** NSKeyedCoder key for timeMillis property. */
+static NSString *const kGDTClockTimeMillisKey = @"GDTClockTimeMillis";
+
+/** NSKeyedCoder key for timezoneOffsetMillis property. */
+static NSString *const kGDTClockTimezoneOffsetSeconds = @"GDTClockTimezoneOffsetSeconds";
+
+/** NSKeyedCoder key for _kernelBootTime ivar. */
+static NSString *const kGDTClockKernelBootTime = @"GDTClockKernelBootTime";
+
+/** NSKeyedCoder key for _uptime ivar. */
+static NSString *const kGDTClockUptime = @"GDTClockUptime";
+
++ (BOOL)supportsSecureCoding {
+  return YES;
+}
+
+- (instancetype)initWithCoder:(NSCoder *)aDecoder {
+  self = [super init];
+  if (self) {
+    // TODO: If the kernelBootTime is more recent, we need to change the kernel boot time and
+    // uptimeMillis ivars
+    _timeMillis = [aDecoder decodeInt64ForKey:kGDTClockTimeMillisKey];
+    _timezoneOffsetSeconds = [aDecoder decodeInt64ForKey:kGDTClockTimezoneOffsetSeconds];
+    _kernelBootTime = [aDecoder decodeInt64ForKey:kGDTClockKernelBootTime];
+    _uptime = [aDecoder decodeInt64ForKey:kGDTClockUptime];
+  }
+  return self;
+}
+
+- (void)encodeWithCoder:(NSCoder *)aCoder {
+  [aCoder encodeInt64:_timeMillis forKey:kGDTClockTimeMillisKey];
+  [aCoder encodeInt64:_timezoneOffsetSeconds forKey:kGDTClockTimezoneOffsetSeconds];
+  [aCoder encodeInt64:_kernelBootTime forKey:kGDTClockKernelBootTime];
+  [aCoder encodeInt64:_uptime forKey:kGDTClockUptime];
+}
+
+@end

GoogleDataTransport/GoogleDataTransport/Classes/GDTConsoleLogger.m

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2018 Google
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#import "GDTConsoleLogger.h"
+
+/** The console logger prefix. */
+static NSString *kGDTConsoleLogger = @"[GoogleDataTransport]";
+
+NSString *GDTMessageCodeEnumToString(GDTMessageCode code) {
+  return [[NSString alloc] initWithFormat:@"I-GDT%06ld", (long)code];
+}
+
+void GDTLog(GDTMessageCode code, NSString *format, ...) {
+// Don't log anything in not debug builds.
+#ifndef NDEBUG
+  NSString *logFormat = [NSString
+      stringWithFormat:@"%@[%@] %@", kGDTConsoleLogger, GDTMessageCodeEnumToString(code), format];
+  va_list args;
+  va_start(args, format);
+  NSLogv(logFormat, args);
+  va_end(args);
+#endif  // NDEBUG
+}