Merge inbound to mozilla-central. a=merge

This is the PDF.js project output, https://github.com/mozilla/pdf.js

Current extension version is: 2.2.91

Current extension version is: 2.2.100

Taken from upstream commit: bce9ff73

Taken from upstream commit: f9c58115

"use strict";

var pdfjsVersion = '2.2.91';

var pdfjsBuild = 'bce9ff73';

var pdfjsVersion = '2.2.100';

var pdfjsBuild = 'f9c58115';

var pdfjsSharedUtil = __w_pdfjs_require__(1);

  return worker.messageHandler.sendWithPromise('GetDocRequest', {

    docId,

    apiVersion: '2.2.91',

    apiVersion: '2.2.100',

    source: {

      data: source.data,

      url: source.url,

  return InternalRenderTask;

}();

const version = '2.2.91';

const version = '2.2.100';

exports.version = version;

const build = 'bce9ff73';

const build = 'f9c58115';

exports.build = build;

/***/ }),

module.exports = function isNodeJS() {

  return typeof process === 'object' && process + '' === '[object process]' && !process.versions['nw'];

  return typeof process === 'object' && process + '' === '[object process]' && !process.versions['nw'] && !process.versions['electron'];

};

/***/ })

"use strict";

const pdfjsVersion = '2.2.91';

const pdfjsBuild = 'bce9ff73';

const pdfjsVersion = '2.2.100';

const pdfjsBuild = 'f9c58115';

const pdfjsCoreWorker = __w_pdfjs_require__(1);

    var WorkerTasks = [];

    const verbosity = (0, _util.getVerbosityLevel)();

    let apiVersion = docParams.apiVersion;

    let workerVersion = '2.2.91';

    let workerVersion = '2.2.100';

    if (apiVersion !== workerVersion) {

      throw new Error(`The API version "${apiVersion}" does not match ` + `the Worker version "${workerVersion}".`);

      var fontCapability = (0, _util.createPromiseCapability)();

      var preEvaluatedFont = this.preEvaluateFont(font);

      var descriptor = preEvaluatedFont.descriptor;

      const {

        descriptor,

        hash

      } = preEvaluatedFont;

      var fontRefIsRef = (0, _primitives.isRef)(fontRef),

          fontID;

        fontID = fontRef.toString();

      }

      if ((0, _primitives.isDict)(descriptor)) {

      if (hash && (0, _primitives.isDict)(descriptor)) {

        if (!descriptor.fontAliases) {

          descriptor.fontAliases = Object.create(null);

        }

        var fontAliases = descriptor.fontAliases;

        var hash = preEvaluatedFont.hash;

        if (fontAliases[hash]) {

          var aliasFontRef = fontAliases[hash].aliasRef;

        });

        try {

          var descriptor = preEvaluatedFont.descriptor;

          var fontFile3 = descriptor && descriptor.get('FontFile3');

          var subtype = fontFile3 && fontFile3.get('Subtype');

          var fontType = (0, _fonts.getFontType)(preEvaluatedFont.type, subtype && subtype.name);

          }

        }

        const firstChar = dict.get('FirstChar') || 0;

        const lastChar = dict.get('LastChar') || (composite ? 0xFFFF : 0xFF);

        hash.update(`${firstChar}-${lastChar}`);

        var toUnicode = dict.get('ToUnicode') || baseDict.get('ToUnicode');

        if ((0, _primitives.isStream)(toUnicode)) {

      if (properties.composite) {

        charCodeToGlyphId = Object.create(null);

        let charCode;

        if (cff.isCIDFont) {

          for (glyphId = 0; glyphId < charsets.length; glyphId++) {

            var cid = charsets[glyphId];

            var charCode = properties.cMap.charCodeOf(cid);

            charCode = properties.cMap.charCodeOf(cid);

            charCodeToGlyphId[charCode] = glyphId;

          }

        } else {

          for (glyphId = 0; glyphId < cff.charStrings.count; glyphId++) {

            charCodeToGlyphId[glyphId] = glyphId;

            charCode = properties.cMap.charCodeOf(glyphId);

            charCodeToGlyphId[charCode] = glyphId;

          }

        }

module.exports = function isNodeJS() {

  return typeof process === 'object' && process + '' === '[object process]' && !process.versions['nw'];

  return typeof process === 'object' && process + '' === '[object process]' && !process.versions['nw'] && !process.versions['electron'];

};

/***/ }),

  # Human-readable identifier for this version/release

  # Generally "version NNN", "tag SSS", "bookmark SSS"

  release: version 2.2.91

  release: version 2.2.100

  # The package's license, where possible using the mnemonic from

  # https://spdx.org/licenses/

  return NS_OK;

}

// Essentially this notification handler implements the

// "Mozilla remote" functionality on Mac, handing command line arguments (passed

// to a newly launched process) to another copy of the current process that was

// already running (which had registered the handler for this notification). All

// other new copies just broadcast this notification and quit (unless -no-remote

// was specified in either of these processes), making the original process handle

// the arguments passed to this handler.

void

remoteClientNotificationCallback(CFNotificationCenterRef aCenter,

                                 void* aObserver, CFStringRef aName,

                                 const void* aObject,

                                 CFDictionaryRef aUserInfo)

{

  // Autorelease pool to prevent memory leaks, in case there is no outer pool.

  mozilla::MacAutoreleasePool pool;

  NSDictionary* userInfoDict = (__bridge NSDictionary*)aUserInfo;

  if (userInfoDict && [userInfoDict objectForKey:@"commandLineArgs"]) {

    NSArray* args = [userInfoDict objectForKey:@"commandLineArgs"];

    nsCOMPtr<nsICommandLineRunner> cmdLine(new nsCommandLine());

    // Converting Objective-C array into a C array,

    // which nsICommandLineRunner understands.

    int argc = [args count];

    const char** argv = new const char*[argc];

    for (int i = 0; i < argc; i++) {

      const char* arg = [[args objectAtIndex:i] UTF8String];

      argv[i] = arg;

    }

    // We're not currently passing the working dir as third argument because it

    // does not appear to be required.

    nsresult rv = cmdLine->Init(argc, argv, nullptr,

                                nsICommandLine::STATE_REMOTE_AUTO);

    // Cleaning up C array.

    delete[] argv;

    if (NS_FAILED(rv)) {

      NS_ERROR("Error initializing command line.");

      return;

    }

    // Processing the command line, passed from a remote instance

    // in the current instance.

    cmdLine->Run();

    // And bring the app's window to front.

    [[NSRunningApplication currentApplication] activateWithOptions:

      NSApplicationActivateIgnoringOtherApps];

  }

}

class nsNativeAppSupportCocoa : public nsNativeAppSupportBase {

 public:

  nsNativeAppSupportCocoa() : mCanShowUI(false) {}

  }

  *_retval = true;

  // Here are the "special" CLI arguments that we can expect to be passed that

  // should alter the default "hand args list to remote process and quit" algorithm:

  // -headless : was already handled on macOS (allowing running multiple instances

  // of the app), meaning this patch shouldn't break it.

  // -no-remote : should always proceed, creating a second instance (which will

  // fail on macOS, showing a MessageBox "Only one instance can be run at a time",

  // unless a different profile dir path is specified).

  // The rest of the arguments should be either passed on to

  // the original running process (exiting the current process), or be processed by

  // the current process (if -no-remote is specified).

  mozilla::MacAutoreleasePool pool;

  NSArray* arguments = [[NSProcessInfo processInfo] arguments];

  BOOL shallProceedLikeNoRemote = NO;

  for (NSString* arg in arguments) {

    if ([arg isEqualToString:@"-no-remote"] || [arg isEqualToString:@"-headless"]) {

      shallProceedLikeNoRemote = YES;

      break;

    }

  }

  BOOL mozillaRestarting = NO;

  if ([[[[NSProcessInfo processInfo] environment] objectForKey:@"MOZ_APP_RESTART"]

       isEqualToString:@"1"]) {

    // Update process completed or restarting the app for another reason.

    // Triggered by an old instance that just quit.

    mozillaRestarting = YES;

  }

  // Apart from -no-remote, the user can specify an env variable

  // MOZ_NO_REMOTE=1, which makes it behave the same way.

  // Also, to make sure the tests do not break,

  // if env var MOZ_TEST_PROCESS_UPDATES is present, it means the test is running.

  // We should proceed as if -no-remote had been specified.

  if (shallProceedLikeNoRemote == NO) {

    NSDictionary* environmentVariables = [[NSProcessInfo processInfo] environment];

    for (NSString* key in [environmentVariables allKeys]) {

      if ([key isEqualToString:@"MOZ_NO_REMOTE"] &&

          [environmentVariables[key] isEqualToString:@"1"]) {

        shallProceedLikeNoRemote = YES;

        break;

      }

    }

  }

  // Now that we have handled no-remote-like arguments, at this point:

  // 1) Either only the first instance of the process has been launched in any way

  //    (.app double click, "open", "open -n", invoking executable in Terminal, etc.

  // 2) Or the process has been launched with a "macos single instance" mechanism

  //    override (using "open -n" OR directly by invoking the executable in Terminal

  //    instead of clicking the .app bundle's icon, etc.).

  // So, let's check if this is the first instance ever of the process for the

  // current user.

  NSString* notificationName = [[[NSBundle mainBundle] bundleIdentifier]

                                stringByAppendingString:

                                @".distributedNotification.commandLineArgs"];

  BOOL runningInstanceFound = NO;

  if (!shallProceedLikeNoRemote) {

    // We check for other running instances only if -no-remote was not specified.

    // The check is needed so the marAppApplyUpdateSuccess.js test doesn't fail on next call.

    runningInstanceFound = [[NSRunningApplication runningApplicationsWithBundleIdentifier:

                              [[NSBundle mainBundle] bundleIdentifier]] count] > 1;

  }

  if (!shallProceedLikeNoRemote && !mozillaRestarting && runningInstanceFound) {

    // There is another instance of this app already running!

    NSArray* arguments = [[NSProcessInfo processInfo] arguments];

    CFDictionaryRef userInfoDict = (__bridge CFDictionaryRef)@{@"commandLineArgs":

                                                                 arguments};

    // This code is shared between Firefox, Thunderbird and other Mozilla products.

    // So we need a notification name that is unique to the product, so we

    // do not send a notification to Firefox from Thunderbird and so on. I am using

    // bundle Id (assuming all Mozilla products come wrapped in .app bundles) -

    // it should be unique

    // (e.g., org.mozilla.firefox.distributedNotification.commandLineArgs for Firefox).

    // We also need to make sure the notifications are "local" to the current user,

    // so we do not pass it on to perhaps another running Thunderbird by another

    // logged in user. Distributed notifications is the best candidate

    // (while darwin notifications ignore the user context).

    CFNotificationCenterPostNotification(CFNotificationCenterGetDistributedCenter(),

                                         (__bridge CFStringRef)notificationName,

                                         NULL,

                                         userInfoDict,

                                         true);

    // Do not continue start up sequence for this process - just self-terminate,

    // we already passed the arguments on to the original instance of the process.

    *_retval = false;

  } else {

    // This is the first instance ever (or launched as -no-remote)!

    // Let's register a notification listener here,

    // In case future instances would want to notify us about command line arguments

    // passed to them. Note, that if mozilla process is restarting, we still need to

    // register for notifications.

    CFNotificationCenterAddObserver(CFNotificationCenterGetDistributedCenter(),

                                    NULL,

                                    remoteClientNotificationCallback,

                                    (__bridge CFStringRef)notificationName,

                                    NULL,

                                    CFNotificationSuspensionBehaviorDeliverImmediately);

    // Continue the start up sequence of this process.

    *_retval = true;

  }

  return NS_OK;

  NS_OBJC_END_TRY_ABORT_BLOCK_NSRESULT;