Merge pull request #1 from mozilla/master

merge to myslef

Author: xiaoyanit

.gitignore

@@ -1,5 +1,4 @@
 # Xcode
-#
 build/
 *.pbxuser
 !default.pbxuser
@@ -16,21 +15,27 @@ DerivedData
 *.hmap
 *.ipa
 *.xcuserstate
+*.xcscmblueprint
 
 # OS X
-#
 .DS_Store
 
 # Vim
 *~
+.*.sw*
 
 # IDEA
 .idea
 
-# CocoaPods
-#
-# We recommend against adding the Pods directory to your .gitignore. However
-# you should judge for yourself, the pros and cons are mentioned at:
-# http://guides.cocoapods.org/using/using-cocoapods.html#should-i-ignore-the-pods-directory-in-source-control
-#
-# Pods/
+Carthage/
+
+ThirdParty/google-breakpad
+
+# Saved Sync credentials for tests.
+signedInUser.json
+
+# Generated config file
+MozBuildID.xcconfig
+
+# Python.
+*.pyc

.gitmodules

@@ -0,0 +1,25 @@
+osx_image: beta-xcode6.3
+language: objective-c
+env:
+  - LC_CTYPE=en_US.UTF-8 LANG=en_US.UTF-8
+before_install:
+  - gem install xcpretty -N
+script:
+  - set -o pipefail
+  - brew update
+  - brew install carthage
+  - ./checkout.sh
+  - rm -rf build
+  - xcodebuild -project Client.xcodeproj -scheme "Firefox" -sdk iphonesimulator -destination "platform=iOS Simulator,name=iPhone 6" ONLY_ACTIVE_ARCH=NO -derivedDataPath build clean test | xcpretty -c
+
+notifications:
+  email: false
+  irc:
+    channels:
+      - "irc.mozilla.org#firefoxios"
+    on_success: change
+    on_failure: always
+
+# This stopped working
+#  - xctool -project Client.xcodeproj -scheme Travis -sdk iphonesimulator ONLY_ACTIVE_ARCH=NO
+#  - xctool test -freshSimulator -project Client.xcodeproj -scheme Travis -sdk iphonesimulator ONLY_ACTIVE_ARCH=NO

.travis.yml

@@ -0,0 +1,17 @@
+This is an (incomplete) list of people who have contributed to the
+codebase which lives in this repository. If you make a contribution
+here, you may add your name and, optionally, email address in the
+appropriate place.
+
+For a full list of the people who are credited with making a
+contribution to Mozilla, see http://www.mozilla.org/credits/.
+
+Brian Nicholson
+Le Van Nghia
+Nick Alexander
+Richard Newman
+Sachin Palewar
+Sahil Wasan
+Stefan Arentz
+Thomas Bonnin
+Wes Johnston

AUTHORS

@@ -0,0 +1,6 @@
+#ifndef Client_Account_Bridging_Header_h
+#define Client_Account_Bridging_Header_h
+
+#import <Foundation/Foundation.h>
+
+#endif

Account/Account-Bridging-Header.h

@@ -0,0 +1,232 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+import Foundation
+import Shared
+import XCGLogger
+
+private let log = Logger.syncLogger
+
+// The version of the account schema we persist.
+let AccountSchemaVersion = 1
+
+/// A FirefoxAccount mediates access to identity attached services.
+///
+/// All data maintained as part of the account or its state should be
+/// considered sensitive and stored appropriately.  Usually, that means
+/// storing account data in the iOS keychain.
+///
+/// Non-sensitive but persistent data should be maintained outside of
+/// the account itself.
+public class FirefoxAccount {
+    /// The email address identifying the account.  A Firefox Account is uniquely identified on a particular server
+    /// (auth endpoint) by its email address.
+    public let email: String
+
+    /// The auth endpoint user identifier identifying the account.  A Firefox Account is uniquely identified on a
+    /// particular server (auth endpoint) by its assigned uid.
+    public let uid: String
+
+    public let configuration: FirefoxAccountConfiguration
+
+    private let stateCache: KeychainCache<FxAState>
+    public var syncAuthState: SyncAuthState! // We can't give a reference to self if this is a let.
+
+    // To prevent advance() consumers racing, we maintain a shared advance() deferred (`advanceDeferred`).  If an
+    // advance() is in progress, the shared deferred will be returned.  (Multiple consumers can chain off a single
+    // deferred safely.)  If no advance() is in progress, a new shared deferred will be scheduled and returned.  To
+    // prevent data races against the shared deferred, advance() locks accesses to `advanceDeferred` using
+    // `advanceLock`.
+    private var advanceLock = OSSpinLock()
+    private var advanceDeferred: Deferred<FxAState>? = nil
+
+    public var actionNeeded: FxAActionNeeded {
+        return stateCache.value!.actionNeeded
+    }
+
+    public convenience init(configuration: FirefoxAccountConfiguration, email: String, uid: String, stateKeyLabel: String, state: FxAState) {
+        self.init(configuration: configuration, email: email, uid: uid, stateCache: KeychainCache(branch: "account.state", label: stateKeyLabel, value: state))
+    }
+
+    public init(configuration: FirefoxAccountConfiguration, email: String, uid: String, stateCache: KeychainCache<FxAState>) {
+        self.email = email
+        self.uid = uid
+        self.configuration = configuration
+        self.stateCache = stateCache
+        self.stateCache.checkpoint()
+        self.syncAuthState = FirefoxAccountSyncAuthState(account: self,
+            cache: KeychainCache.fromBranch("account.syncAuthState", withLabel: self.stateCache.label, factory: syncAuthStateCachefromJSON))
+    }
+
+    public class func fromConfigurationAndJSON(configuration: FirefoxAccountConfiguration, data: JSON) -> FirefoxAccount? {
+        if let email = data["email"].asString {
+            if let uid = data["uid"].asString {
+                if let sessionToken = data["sessionToken"].asString?.hexDecodedData {
+                    if let keyFetchToken = data["keyFetchToken"].asString?.hexDecodedData {
+                        if let unwrapkB = data["unwrapBKey"].asString?.hexDecodedData {
+                            let verified = data["verified"].asBool ?? false
+                            return FirefoxAccount.fromConfigurationAndParameters(configuration,
+                                email: email, uid: uid, verified: verified,
+                                sessionToken: sessionToken, keyFetchToken: keyFetchToken, unwrapkB: unwrapkB)
+                        }
+                    }
+                }
+            }
+        }
+        return nil
+    }
+
+    public class func fromConfigurationAndLoginResponse(configuration: FirefoxAccountConfiguration,
+            response: FxALoginResponse, unwrapkB: NSData) -> FirefoxAccount {
+        return FirefoxAccount.fromConfigurationAndParameters(configuration,
+            email: response.remoteEmail, uid: response.uid, verified: response.verified,
+            sessionToken: response.sessionToken, keyFetchToken: response.keyFetchToken, unwrapkB: unwrapkB)
+    }
+
+    private class func fromConfigurationAndParameters(configuration: FirefoxAccountConfiguration,
+            email: String, uid: String, verified: Bool,
+            sessionToken: NSData, keyFetchToken: NSData, unwrapkB: NSData) -> FirefoxAccount {
+        var state: FxAState! = nil
+        if !verified {
+            let now = NSDate.now()
+            state = EngagedBeforeVerifiedState(knownUnverifiedAt: now,
+                lastNotifiedUserAt: now,
+                sessionToken: sessionToken,
+                keyFetchToken: keyFetchToken,
+                unwrapkB: unwrapkB
+            )
+        } else {
+            state = EngagedAfterVerifiedState(
+                sessionToken: sessionToken,
+                keyFetchToken: keyFetchToken,
+                unwrapkB: unwrapkB
+            )
+        }
+
+        let account = FirefoxAccount(
+            configuration: configuration,
+            email: email,
+            uid: uid,
+            stateKeyLabel: Bytes.generateGUID(),
+            state: state
+        )
+        return account
+    }
+
+    public func asDictionary() -> [String: AnyObject] {
+        var dict: [String: AnyObject] = [:]
+        dict["version"] = AccountSchemaVersion
+        dict["email"] = email
+        dict["uid"] = uid
+        dict["configurationLabel"] = configuration.label.rawValue
+        dict["stateKeyLabel"] = stateCache.label
+        return dict
+    }
+
+    public class func fromDictionary(dictionary: [String: AnyObject]) -> FirefoxAccount? {
+        if let version = dictionary["version"] as? Int {
+            if version == AccountSchemaVersion {
+                return FirefoxAccount.fromDictionaryV1(dictionary)
+            }
+        }
+        return nil
+    }
+
+    private class func fromDictionaryV1(dictionary: [String: AnyObject]) -> FirefoxAccount? {
+        var configurationLabel: FirefoxAccountConfigurationLabel? = nil
+        if let rawValue = dictionary["configurationLabel"] as? String {
+            configurationLabel = FirefoxAccountConfigurationLabel(rawValue: rawValue)
+        }
+        if let
+            configurationLabel = configurationLabel,
+            email = dictionary["email"] as? String,
+            uid = dictionary["uid"] as? String {
+                let stateCache = KeychainCache.fromBranch("account.state", withLabel: dictionary["stateKeyLabel"] as? String, withDefault: SeparatedState(), factory: stateFromJSON)
+                return FirefoxAccount(
+                    configuration: configurationLabel.toConfiguration(),
+                    email: email, uid: uid,
+                    stateCache: stateCache)
+        }
+        return nil
+    }
+
+    public enum AccountError: MaybeErrorType {
+        case NotMarried
+
+        public var description: String {
+            switch self {
+            case NotMarried: return "Not married."
+            }
+        }
+    }
+
+    public func advance() -> Deferred<FxAState> {
+        OSSpinLockLock(&advanceLock)
+        if let deferred = advanceDeferred {
+            // We already have an advance() in progress.  This consumer can chain from it.
+            log.debug("advance already in progress; returning shared deferred.")
+            OSSpinLockUnlock(&advanceLock)
+            return deferred
+        }
+
+        // Alright, we haven't an advance() in progress.  Schedule a new deferred to chain from.
+        let client = FxAClient10(endpoint: configuration.authEndpointURL)
+        let stateMachine = FxALoginStateMachine(client: client)
+        let now = NSDate.now()
+        let deferred: Deferred<FxAState> = stateMachine.advanceFromState(stateCache.value!, now: now).map { newState in
+            self.stateCache.value = newState
+            return newState
+        }
+        advanceDeferred = deferred
+        log.debug("no advance() in progress; setting and returning new shared deferred.")
+        OSSpinLockUnlock(&advanceLock)
+
+        deferred.upon { _ in
+            // This advance() is complete.  Clear the shared deferred.
+            OSSpinLockLock(&self.advanceLock)
+            if let existingDeferred = self.advanceDeferred where existingDeferred === deferred {
+                // The guard should not be needed, but should prevent trampling racing consumers.
+                self.advanceDeferred = nil
+                log.debug("advance() completed and shared deferred is existing deferred; clearing shared deferred.")
+            } else {
+                log.warning("advance() completed but shared deferred is not existing deferred; ignoring potential bug!")
+            }
+            OSSpinLockUnlock(&self.advanceLock)
+        }
+        return deferred
+    }
+
+    public func marriedState() -> Deferred<Maybe<MarriedState>> {
+        return advance().map { newState in
+            if newState.label == FxAStateLabel.Married {
+                if let married = newState as? MarriedState {
+                    return Maybe(success: married)
+                }
+            }
+            return Maybe(failure: AccountError.NotMarried)
+        }
+    }
+
+    public func makeSeparated() -> Bool {
+        log.info("Making Account State be Separated.")
+        self.stateCache.value = SeparatedState()
+        return true
+    }
+
+    public func makeDoghouse() -> Bool {
+        log.info("Making Account State be Doghouse.")
+        self.stateCache.value = DoghouseState()
+        return true
+    }
+
+    public func makeCohabitingWithoutKeyPair() -> Bool {
+        if let married = self.stateCache.value as? MarriedState {
+            log.info("Making Account State be CohabitingWithoutKeyPair.")
+            self.stateCache.value = married.withoutKeyPair()
+            return true
+        }
+        log.info("Cannot make Account State be CohabitingWithoutKeyPair from state with label \(self.stateCache.value?.label).")
+        return false
+    }
+}