Use mojo from the PDF extension instead of using an extension API.

chrome/browser/resources/pdf/browser_api.js

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 'use strict';
 
 /**
  * Returns a promise that will resolve to the default zoom factor.
  * @param {!Object} streamInfo The stream object pointing to the data contained
  *     in the PDF.
@@ skipping 38 matching lines @@
  */
 class BrowserApi {
   /**
    * @constructor
    * @param {!Object} streamInfo The stream object which points to the data
    *     contained in the PDF.
    * @param {number} defaultZoom The default browser zoom.
    * @param {number} initialZoom The initial browser zoom
    *     upon starting the plugin.
    * @param {boolean} manageZoom Whether to manage zoom.
+   * @param {Function} abortStream A function that can be called to abort the
+   *     stream
    */
-  constructor(streamInfo, defaultZoom, initialZoom, manageZoom) {
+  constructor(streamInfo, defaultZoom, initialZoom, manageZoom, abortStream) {
     this.streamInfo_ = streamInfo;
     this.defaultZoom_ = defaultZoom;
     this.initialZoom_ = initialZoom;
     this.manageZoom_ = manageZoom;
+    this.abortStream_ = abortStream;
   }
 
   /**
    * Returns a promise to a BrowserApi.
    * @param {!Object} streamInfo The stream object pointing to the data
    *     contained in the PDF.
    * @param {boolean} manageZoom Whether to manage zoom.
+   * @param {Function} abortStream A function that can be called to abort the
+   *     stream
    */
-  static create(streamInfo, manageZoom) {
-    return Promise.all([
-        lookupDefaultZoom(streamInfo),
-        lookupInitialZoom(streamInfo)
-    ]).then(function(zoomFactors) {
-      return new BrowserApi(
-          streamInfo, zoomFactors[0], zoomFactors[1], manageZoom);
-    });
+  static async create(streamInfo, manageZoom, abortStream) {
+    let [defaultZoom, initialZoom] = await Promise.all([
+        lookupDefaultZoom(streamInfo), lookupInitialZoom(streamInfo)]);
+    return new BrowserApi(
+          streamInfo, defaultZoom, initialZoom, manageZoom, abortStream);
   }
 
   /**
    * Returns the stream info pointing to the data contained in the PDF.
    * @return {Object} The stream info object.
    */
   getStreamInfo() {
     return this.streamInfo_;
   }
 
   /**
    * Aborts the stream.
    */
   abortStream() {
-    if (chrome.mimeHandlerPrivate)
-      chrome.mimeHandlerPrivate.abortStream();
+    this.abortStream_();
   }
 
   /**
    * Sets the browser zoom.
    * @param {number} zoom The zoom factor to send to the browser.
    * @return {Promise} A promise that will be resolved when the browser zoom
    *     has been updated.
    */
   setZoom(zoom) {
     if (!this.manageZoom_)
@@ skipping 29 matching lines @@
       return;
 
     chrome.tabs.onZoomChange.addListener(function(zoomChangeInfo) {
       if (zoomChangeInfo.tabId != this.streamInfo_.tabId)
         return;
       listener(zoomChangeInfo.newZoomFactor);
     }.bind(this));
   }
 };
 
+function constructStreamInfoDict_(streamInfo) {
+  var headers = {};
+  for (var header of streamInfo.response_headers) {
+    headers[header[0]] = header[1];
+  }
+  return {
+    mimeType: streamInfo.mime_type,
+    originalUrl: streamInfo.original_url,
+    streamUrl: streamInfo.stream_url,
+    tabId: streamInfo.tab_id,
+    embedded: !!streamInfo.embedded,
+    responseHeaders: headers,
+  };
+}
+
 /**
  * Creates a BrowserApi for an extension running as a mime handler.
  * @return {Promise<BrowserApi>} A promise to a BrowserApi instance constructed
- *     using the mimeHandlerPrivate API.
+ *     using the MimeHandlerService interface.
  */
-function createBrowserApiForMimeHandlerView() {
-  return new Promise(function(resolve, reject) {
-    chrome.mimeHandlerPrivate.getStreamInfo(resolve);
-  }).then(function(streamInfo) {
-    let promises = [];
-    let manageZoom = !streamInfo.embedded && streamInfo.tabId != -1;
-    if (streamInfo.tabId != -1) {
-      promises.push(new Promise(function(resolve) {
+async function createBrowserApiForMimeHandlerView() {
+  let mimeHandlerInterface = await (async function() {
+    if (!define)
+      return;
+
+    let [frameInterfaces, mojom, connectionModule] = await new Promise(
+        resolve => {
+      define('pdf_browser_api', [
+          'content/public/renderer/frame_interfaces',
+          'extensions/common/api/mime_handler.mojom',
+          'mojo/public/js/connection',
+      ], (...modules) => resolve(modules));
+    });
+    return connectionModule.bindHandleToProxy(
+        frameInterfaces.getInterface(mojom.MimeHandlerService.name),
+        mojom.MimeHandlerService);
+  })();
+
+  let streamInfo = constructStreamInfoDict_(
+      (await mimeHandlerInterface.getStreamInfo()).stream_info);
+
+  let promises = [];
+  let manageZoom = !streamInfo.embedded && streamInfo.tabId != -1;
+  if (streamInfo.tabId != -1) {
+    promises.push((async function() {
+      let tab = await new Promise(function(resolve) {
         chrome.tabs.get(streamInfo.tabId, resolve);
-      }).then(function(tab) {
-        if (tab)
-          streamInfo.tabUrl = tab.url;
-      }));
-    }
-    if (manageZoom) {
-      promises.push(new Promise(function(resolve) {
-        chrome.tabs.setZoomSettings(
-            streamInfo.tabId, {mode: 'manual', scope: 'per-tab'}, resolve);
-      }));
-    }
-    return Promise.all(promises).then(
-        function() { return BrowserApi.create(streamInfo, manageZoom); });
-  });
+      });
+      if (tab)
+        streamInfo.tabUrl = tab.url;
+    })());
+  }
+  if (manageZoom) {
+    promises.push(new Promise(function(resolve) {
+      chrome.tabs.setZoomSettings(
+          streamInfo.tabId, {mode: 'manual', scope: 'per-tab'}, resolve);
+    }));
+  }
+  await Promise.all(promises);
+  return BrowserApi.create(
+      streamInfo, manageZoom, () => { mimeHandlerInterface.abortStream(); });
 }
 
 /**
  * Creates a BrowserApi instance for an extension not running as a mime handler.
  * @return {Promise<BrowserApi>} A promise to a BrowserApi instance constructed
  *     from the URL.
  */
-function createBrowserApiForStandaloneExtension() {
+async function createBrowserApiForStandaloneExtension() {
   let url = window.location.search.substring(1);
   let streamInfo = {
     streamUrl: url,
     originalUrl: url,
     responseHeaders: {},
     embedded: window.parent != window,
     tabId: -1,
   };
-  return new Promise(function(resolve, reject) {
-    if (!chrome.tabs) {
-      resolve();
-      return;
-    }
-    chrome.tabs.getCurrent(function(tab) {
-      streamInfo.tabId = tab.id;
-      streamInfo.tabUrl = tab.url;
-      resolve();
+  if (chrome.tabs) {
+    let tab = await new Promise(resolve => {
+      chrome.tabs.getCurrent(resolve);
     });
-  }).then(function() { return BrowserApi.create(streamInfo, false); });
+    streamInfo.tabId = tab.id;
+    streamInfo.tabUrl = tab.url;
+  }
+  return BrowserApi.create(streamInfo, false, () => {});
 }
 
 /**
  * Returns a promise that will resolve to a BrowserApi instance.
  * @return {Promise<BrowserApi>} A promise to a BrowserApi instance for the
  *     current environment.
  */
 function createBrowserApi() {
   if (window.location.search)
     return createBrowserApiForStandaloneExtension();
 
   return createBrowserApiForMimeHandlerView();
 }