Merge mozilla-central to autoland. a=merge CLOSED TREE
authorshindli <shindli@mozilla.com>
Wed, 24 Oct 2018 19:50:03 +0300
changeset 491169 d1052b2d28f6c4239e8870465ccc09ef95f308ac
parent 491168 0b9e4abc5911fb241ba351c07e7cc2f3e4fb2ed7 (current diff)
parent 491126 09d302af0a59dadf990400f18e426766e25f21db (diff)
child 491170 74998050fbc4bf8da4dab2626c033cec0b34dbfb
push id247
push userfmarier@mozilla.com
push dateSat, 27 Oct 2018 01:06:44 +0000
reviewersmerge
milestone65.0a1
Merge mozilla-central to autoland. a=merge CLOSED TREE
browser/components/preferences/in-content/preferences.xul
toolkit/mozapps/extensions/content/eula.js
toolkit/mozapps/extensions/content/eula.xul
toolkit/themes/osx/mozapps/extensions/eula.css
toolkit/themes/windows/mozapps/extensions/eula.css
widget/gtk/gtk2drawing.c
--- a/browser/app/profile/firefox.js
+++ b/browser/app/profile/firefox.js
@@ -1502,18 +1502,19 @@ pref("toolkit.telemetry.hybridContent.en
 pref("browser.ping-centre.telemetry", true);
 pref("browser.ping-centre.log", false);
 pref("browser.ping-centre.staging.endpoint", "https://onyx_tiles.stage.mozaws.net/v3/links/ping-centre");
 pref("browser.ping-centre.production.endpoint", "https://tiles.services.mozilla.com/v3/links/ping-centre");
 
 // Enable GMP support in the addon manager.
 pref("media.gmp-provider.enabled", true);
 
-// Enable blocking access to storage from tracking resources by default on Nightly
-#ifdef NIGHTLY_BUILD
+// Enable blocking access to storage from tracking resources by default on
+// Nightly and Beta
+#ifdef EARLY_BETA_OR_EARLIER
 pref("network.cookie.cookieBehavior", 4 /* BEHAVIOR_REJECT_TRACKER */);
 #endif
 
 pref("browser.contentblocking.allowlist.storage.enabled", true);
 
 #ifdef NIGHTLY_BUILD
 pref("browser.contentblocking.global-toggle.enabled", true);
 #else
--- a/browser/base/content/browser.js
+++ b/browser/base/content/browser.js
@@ -4669,29 +4669,34 @@ var XULBrowserWindow = {
   get stopCommand() {
     delete this.stopCommand;
     return this.stopCommand = document.getElementById("Browser:Stop");
   },
   get reloadCommand() {
     delete this.reloadCommand;
     return this.reloadCommand = document.getElementById("Browser:Reload");
   },
-  get elementsForTextBasedTypes() {
-    delete this.elementsForTextBasedTypes;
-    return this.elementsForTextBasedTypes = [
+  get _elementsForTextBasedTypes() {
+    delete this._elementsForTextBasedTypes;
+    return this._elementsForTextBasedTypes = [
       document.getElementById("pageStyleMenu"),
       document.getElementById("context-viewpartialsource-selection"),
+    ];
+  },
+  get _elementsForFind() {
+    delete this._elementsForFind;
+    return this._elementsForFind = [
       document.getElementById("cmd_find"),
       document.getElementById("cmd_findAgain"),
       document.getElementById("cmd_findPrevious"),
     ];
   },
-  get elementsForViewSource() {
-    delete this.elementsForViewSource;
-    return this.elementsForViewSource = [
+  get _elementsForViewSource() {
+    delete this._elementsForViewSource;
+    return this._elementsForViewSource = [
       document.getElementById("context-viewsource"),
       document.getElementById("View:PageSource"),
     ];
   },
 
   forceInitialBrowserNonRemote(aOpener) {
     gBrowser.updateBrowserRemoteness(gBrowser.initialBrowser, false, { opener: aOpener });
   },
@@ -4835,34 +4840,28 @@ var XULBrowserWindow = {
                 break;
             }
           }
         }
 
         this.status = "";
         this.setDefaultStatus(msg);
 
-        // Disable menu entries for images, enable otherwise
+        // Disable View Source menu entries for images, enable otherwise
         let isText = browser.documentContentType &&
                      BrowserUtils.mimeTypeIsTextBased(browser.documentContentType);
-        for (let element of this.elementsForTextBasedTypes) {
-          if (isText) {
-            element.removeAttribute("disabled");
-          } else {
-            element.setAttribute("disabled", "true");
-          }
-        }
-
-        for (let element of this.elementsForViewSource) {
+        for (let element of this._elementsForViewSource) {
           if (canViewSource && isText) {
             element.removeAttribute("disabled");
           } else {
             element.setAttribute("disabled", "true");
           }
         }
+
+        this._updateElementsForContentType();
       }
 
       this.isBusy = false;
 
       if (this.busyUI) {
         this.busyUI = false;
 
         this.stopCommand.setAttribute("disabled", "true");
@@ -4887,29 +4886,16 @@ var XULBrowserWindow = {
           if (tooltipWindow == aWebProgress.DOMWindow) {
             pageTooltip.hidePopup();
             break;
           }
         }
       }
     }
 
-    let browser = gBrowser.selectedBrowser;
-
-    // Disable menu entries for images, enable otherwise
-    let isText = browser.documentContentType &&
-                 BrowserUtils.mimeTypeIsTextBased(browser.documentContentType);
-    for (let element of this.elementsForTextBasedTypes) {
-      if (isText) {
-        element.removeAttribute("disabled");
-      } else {
-        element.setAttribute("disabled", "true");
-      }
-    }
-
     this.hideOverLinkImmediately = true;
     this.setOverLink("", null);
     this.hideOverLinkImmediately = false;
 
     // We should probably not do this if the value has changed since the user
     // searched
     // Update urlbar only if a new page was loaded on the primary content area
     // Do not update urlbar if there was a subframe navigation
@@ -4934,56 +4920,17 @@ var XULBrowserWindow = {
       gIdentityHandler.onLocationChange();
 
       BrowserPageActions.onLocationChange();
 
       SafeBrowsingNotificationBox.onLocationChange(aLocationURI);
 
       gTabletModePageCounter.inc();
 
-      // Utility functions for disabling find
-      var shouldDisableFind = function(aDocument) {
-        let docElt = aDocument.documentElement;
-        return docElt && docElt.getAttribute("disablefastfind") == "true";
-      };
-
-      var disableFindCommands = function(aDisable) {
-        let findCommands = [document.getElementById("cmd_find"),
-                            document.getElementById("cmd_findAgain"),
-                            document.getElementById("cmd_findPrevious")];
-        for (let elt of findCommands) {
-          if (aDisable)
-            elt.setAttribute("disabled", "true");
-          else
-            elt.removeAttribute("disabled");
-        }
-      };
-
-      var onContentRSChange = function(e) {
-        if (e.target.readyState != "interactive" && e.target.readyState != "complete")
-          return;
-
-        e.target.removeEventListener("readystatechange", onContentRSChange);
-        disableFindCommands(shouldDisableFind(e.target));
-      };
-
-      // Disable find commands in documents that ask for them to be disabled.
-      if (!gMultiProcessBrowser && aLocationURI &&
-          (aLocationURI.schemeIs("about") || aLocationURI.schemeIs("chrome"))) {
-        // Don't need to re-enable/disable find commands for same-document location changes
-        // (e.g. the replaceStates in about:addons)
-        if (!(aFlags & Ci.nsIWebProgressListener.LOCATION_CHANGE_SAME_DOCUMENT)) {
-          if (window.content.document.readyState == "interactive" || window.content.document.readyState == "complete")
-            disableFindCommands(shouldDisableFind(window.content.document));
-          else {
-            window.content.document.addEventListener("readystatechange", onContentRSChange);
-          }
-        }
-      } else
-        disableFindCommands(false);
+      this._updateElementsForContentType();
 
       // Try not to instantiate gCustomizeMode as much as possible,
       // so don't use CustomizeMode.jsm to check for URI or customizing.
       if (location == "about:blank" &&
           gBrowser.selectedTab.hasAttribute("customizemode")) {
         gCustomizeMode.enter();
       } else if (CustomizationHandler.isEnteringCustomizeMode ||
                  CustomizationHandler.isCustomizing()) {
@@ -5020,16 +4967,42 @@ var XULBrowserWindow = {
         // Don't make noise when the crash reporter is built but not enabled.
         if (ex.result != Cr.NS_ERROR_NOT_INITIALIZED) {
           throw ex;
         }
       }
     }
   },
 
+  _updateElementsForContentType() {
+    let browser = gBrowser.selectedBrowser;
+
+    let isText = browser.documentContentType &&
+                 BrowserUtils.mimeTypeIsTextBased(browser.documentContentType);
+    for (let element of this._elementsForTextBasedTypes) {
+      if (isText) {
+        element.removeAttribute("disabled");
+      } else {
+        element.setAttribute("disabled", "true");
+      }
+    }
+
+    // Always enable find commands in PDF documents, otherwise do it only for
+    // text documents whose location is not in the blacklist.
+    let enableFind = browser.documentContentType == "application/pdf" ||
+      (isText && BrowserUtils.canFindInPage(gBrowser.currentURI.spec));
+    for (let element of this._elementsForFind) {
+      if (enableFind) {
+        element.removeAttribute("disabled");
+      } else {
+        element.setAttribute("disabled", "true");
+      }
+    }
+  },
+
   asyncUpdateUI() {
     BrowserSearch.updateOpenSearchBadge();
   },
 
   onStatusChange(aWebProgress, aRequest, aStatus, aMessage) {
     this.status = aMessage;
     StatusPanel.update();
   },
--- a/browser/base/content/test/general/browser_viewSourceInTabOnViewSource.js
+++ b/browser/base/content/test/general/browser_viewSourceInTabOnViewSource.js
@@ -8,42 +8,42 @@ function wait_while_tab_is_busy() {
         }
       },
     };
     gBrowser.addProgressListener(progressListener);
   });
 }
 
 // This function waits for the tab to stop being busy instead of waiting for it
-// to load, since the elementsForViewSource change happens at that time.
+// to load, since the _elementsForViewSource change happens at that time.
 var with_new_tab_opened = async function(options, taskFn) {
   let busyPromise = wait_while_tab_is_busy();
   let tab = await BrowserTestUtils.openNewForegroundTab(options.gBrowser, options.url, false);
   await busyPromise;
   await taskFn(tab.linkedBrowser);
   gBrowser.removeTab(tab);
 };
 
 add_task(async function test_regular_page() {
   function test_expect_view_source_enabled(browser) {
-    for (let element of [...XULBrowserWindow.elementsForViewSource]) {
+    for (let element of [...XULBrowserWindow._elementsForViewSource]) {
       ok(!element.hasAttribute("disabled"),
          "View Source should be enabled");
     }
   }
 
   await with_new_tab_opened({
     gBrowser,
     url: "http://example.com",
   }, test_expect_view_source_enabled);
 });
 
 add_task(async function test_view_source_page() {
   function test_expect_view_source_disabled(browser) {
-    for (let element of [...XULBrowserWindow.elementsForViewSource]) {
+    for (let element of [...XULBrowserWindow._elementsForViewSource]) {
       ok(element.hasAttribute("disabled"),
          "View Source should be disabled");
     }
   }
 
   await with_new_tab_opened({
     gBrowser,
     url: "view-source:http://example.com",
--- a/browser/components/preferences/in-content/preferences.xul
+++ b/browser/components/preferences/in-content/preferences.xul
@@ -28,17 +28,16 @@
 %historyDTD;
 %certManagerDTD;
 %deviceManangerDTD;
 %sanitizeDTD;
 ]>
 
 <page xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
       xmlns:html="http://www.w3.org/1999/xhtml"
-      disablefastfind="true"
       data-l10n-id="pref-page"
       data-l10n-attrs="title">
 
   <linkset>
     <link rel="localization" href="branding/brand.ftl"/>
     <link rel="localization" href="browser/branding/sync-brand.ftl"/>
     <link rel="localization" href="browser/preferences/preferences.ftl"/>
     <!-- Used by fontbuilder.js -->
--- a/browser/components/urlbar/UrlbarInput.jsm
+++ b/browser/components/urlbar/UrlbarInput.jsm
@@ -225,17 +225,27 @@ class UrlbarInput {
 
   /**
    * Called by the view when a result is selected.
    *
    * @param {Event} event The event that selected the result.
    * @param {UrlbarMatch} result The result that was selected.
    */
   resultSelected(event, result) {
-    // TODO: Set the input value to the target url.
+    // Set the input value to the target url.
+    let val = result.url;
+    let uri;
+    try {
+      uri = Services.io.newURI(val);
+    } catch (ex) {}
+    if (uri) {
+      val = this.window.losslessDecodeURI(uri);
+    }
+    this.value = val;
+
     this.controller.resultSelected(event, result);
   }
 
   // Getters and Setters below.
 
   get focused() {
     return this.textbox.getAttribute("focused") == "true";
   }
--- a/browser/components/urlbar/tests/browser/browser_UrlbarController_resultOpening.js
+++ b/browser/components/urlbar/tests/browser/browser_UrlbarController_resultOpening.js
@@ -54,17 +54,23 @@ add_task(function test_resultSelected_sw
   sandbox.stub(window, "switchToTabHavingURI").returns(true);
   sandbox.stub(window, "isTabEmpty").returns(false);
   sandbox.stub(window.gBrowser, "removeTab");
 
   const event = new MouseEvent("click", {button: 0});
   const url = "https://example.com/1";
   const result = new UrlbarMatch(UrlbarUtils.MATCH_TYPE.TAB_SWITCH, {url});
 
-  controller.resultSelected(event, result);
+  Assert.equal(gURLBar.value, "", "urlbar input is empty before selecting a result");
+  if (Services.prefs.getBoolPref("browser.urlbar.quantumbar", true)) {
+    gURLBar.resultSelected(event, result);
+    Assert.equal(gURLBar.value, url, "urlbar value updated for selected result");
+  } else {
+    controller.resultSelected(event, result);
+  }
 
   Assert.ok(window.switchToTabHavingURI.calledOnce,
     "Should have triggered switching to the tab");
 
   let args = window.switchToTabHavingURI.args[0];
 
   Assert.equal(args[0], url, "Should have passed the expected url");
   Assert.ok(!args[1], "Should not attempt to open a new tab");
--- a/caps/tests/mochitest/test_bug292789.html
+++ b/caps/tests/mochitest/test_bug292789.html
@@ -8,17 +8,17 @@ https://bugzilla.mozilla.org/show_bug.cg
   <script type="text/javascript" src="/tests/SimpleTest/SimpleTest.js"></script>
   <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
 </head>
 <body>
 <a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=292789">Mozilla Bug 292789</a>
 <p id="display"></p>
 <div id="content" style="display: none">
   <script src="chrome://global/content/treeUtils.js"></script>
-  <script type="application/javascript" src="chrome://mozapps/content/extensions/eula.js"></script>
+  <script type="application/javascript" src="chrome://mozapps/content/extensions/blocklist.js"></script>
   <script id="resjs" type="application/javascript"></script>
 </div>
 <pre id="test">
 <script class="testbody" type="text/javascript">
 
 /** Test for Bug 292789
  **
  ** Selectively allow access to whitelisted chrome packages
@@ -40,22 +40,22 @@ function testScriptSrc(aCallback) {
     is(typeof Startup, "undefined",
        "content should not be able to load <script> from chrome://mozapps");
 
     /** make sure the last one didn't pass because someone
      ** moved the resource
      **/
     var resjs = document.getElementById("resjs");
     resjs.onload = scriptOnload;
-    resjs.src = "resource://gre/chrome/toolkit/content/mozapps/extensions/eula.js";
+    resjs.src = "resource://gre/chrome/toolkit/content/mozapps/extensions/blocklist.js";
     document.getElementById("content").appendChild(resjs);
 
     function scriptOnload() {
-      is(typeof Startup, "function",
-         "extensions.js has not moved unexpectedly");
+      is(typeof init, "function",
+         "blocklist.js has not moved unexpectedly");
 
       // trigger the callback
       if (aCallback)
         aCallback();
     }
 }
 
 /** <img src=""> tests **/
--- a/devtools/client/inspector/test/browser.ini
+++ b/devtools/client/inspector/test/browser.ini
@@ -77,17 +77,17 @@ skip-if = os == "mac" # Full keyboard na
 [browser_inspector_highlighter-cancel.js]
 [browser_inspector_highlighter-comments.js]
 [browser_inspector_highlighter-cssgrid_01.js]
 [browser_inspector_highlighter-cssgrid_02.js]
 [browser_inspector_highlighter-cssshape_01.js]
 [browser_inspector_highlighter-cssshape_02.js]
 [browser_inspector_highlighter-cssshape_03.js]
 [browser_inspector_highlighter-cssshape_04.js]
-skip-if = (os == 'win' && (debug||asan)) || (os == 'linux' && bits == 64 && !debug) # Bug 1453214
+skip-if = (os == 'win' && (debug||asan)) || (os == 'linux') # Bug 1453214
 [browser_inspector_highlighter-cssshape_05.js]
 [browser_inspector_highlighter-cssshape_06-scale.js]
 [browser_inspector_highlighter-cssshape_06-translate.js]
 [browser_inspector_highlighter-cssshape_07.js]
 [browser_inspector_highlighter-cssshape_iframe_01.js]
 skip-if = (verify && debug)
 [browser_inspector_highlighter-csstransform_01.js]
 [browser_inspector_highlighter-csstransform_02.js]
--- a/js/src/builtin/ModuleObject.cpp
+++ b/js/src/builtin/ModuleObject.cpp
@@ -1839,28 +1839,37 @@ js::StartDynamicModuleImport(JSContext* 
 
     RootedObject promiseObject(cx, JS::NewPromiseObject(cx, nullptr));
     if (!promiseObject) {
         return nullptr;
     }
 
     Handle<PromiseObject*> promise = promiseObject.as<PromiseObject>();
 
-    RootedString specifier(cx, ToString(cx, specifierArg));
-    if (!specifier) {
-        if (!RejectPromiseWithPendingError(cx, promise))
+    JS::ModuleDynamicImportHook importHook = cx->runtime()->moduleDynamicImportHook;
+    if (!importHook) {
+        JS_ReportErrorASCII(cx, "Dynamic module import is disabled");
+        if (!RejectPromiseWithPendingError(cx, promise)) {
             return nullptr;
+        }
         return promise;
     }
 
-    JS::ModuleDynamicImportHook importHook = cx->runtime()->moduleDynamicImportHook;
-    MOZ_ASSERT(importHook);
+    RootedString specifier(cx, ToString(cx, specifierArg));
+    if (!specifier) {
+        if (!RejectPromiseWithPendingError(cx, promise)) {
+            return nullptr;
+        }
+        return promise;
+    }
+
     if (!importHook(cx, referencingPrivate, specifier, promise)) {
-        if (!RejectPromiseWithPendingError(cx, promise))
+        if (!RejectPromiseWithPendingError(cx, promise)) {
             return nullptr;
+        }
         return promise;
     }
 
     return promise;
 }
 
 bool
 js::FinishDynamicModuleImport(JSContext* cx, HandleValue referencingPrivate, HandleString specifier,
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/modules/bug-1501154.js
@@ -0,0 +1,25 @@
+// Test using an empty string as a module specifier fails.
+let result = null;
+let error = null;
+let promise = import("");
+promise.then((ns) => {
+    result = ns;
+}).catch((e) => {
+    error = e;
+});
+
+drainJobQueue();
+assertEq(result, null);
+assertEq(error instanceof Error, true);
+
+// Test reading a directory as a file fails.
+result = null;
+error = null;
+try {
+    result = os.file.readFile(".");
+} catch (e) {
+    error = e;
+}
+
+assertEq(result, null);
+assertEq(error instanceof Error, true);
new file mode 100644
--- /dev/null
+++ b/js/src/jit-test/tests/modules/bug-1501157.js
@@ -0,0 +1,2 @@
+// |jit-test| skip-if: helperThreadCount() === 0
+offThreadCompileScript('import("")', {});
--- a/js/src/shell/ModuleLoader.js
+++ b/js/src/shell/ModuleLoader.js
@@ -33,16 +33,20 @@ const ReflectLoader = new class {
         this.loadPath = getModuleLoadPath();
     }
 
     isJavascriptURL(name) {
         return ReflectApply(StringPrototypeStartsWith, name, [JAVASCRIPT_SCHEME]);
     }
 
     resolve(name, referencingInfo) {
+        if (name === "") {
+            throw new ErrorClass("Invalid module specifier");
+        }
+
         if (this.isJavascriptURL(name) || os.path.isAbsolute(name)) {
             return name;
         }
 
         let loadPath = this.loadPath;
 
         // Treat |name| as a relative path if it starts with either "./"
         // or "../".
--- a/js/src/shell/js.cpp
+++ b/js/src/shell/js.cpp
@@ -2271,37 +2271,55 @@ js::shell::FileAsString(JSContext* cx, J
     file = fopen(pathname.get(), "rb");
     if (!file) {
         ReportCantOpenErrorUnknownEncoding(cx, pathname.get());
         return nullptr;
     }
 
     AutoCloseFile autoClose(file);
 
+    struct stat st;
+    if (fstat(fileno(file), &st) != 0) {
+        JS_ReportErrorUTF8(cx, "can't stat %s", pathname.get());
+        return nullptr;
+    }
+
+    if ((st.st_mode & S_IFMT) != S_IFREG) {
+        JS_ReportErrorUTF8(cx, "can't read non-regular file %s", pathname.get());
+        return nullptr;
+    }
+
     if (fseek(file, 0, SEEK_END) != 0) {
         pathname = JS_EncodeStringToUTF8(cx, pathnameStr);
         if (!pathname) {
             return nullptr;
         }
         JS_ReportErrorUTF8(cx, "can't seek end of %s", pathname.get());
         return nullptr;
     }
 
-    size_t len = ftell(file);
+    long endPos = ftell(file);
+    if (endPos < 0) {
+        JS_ReportErrorUTF8(cx, "can't read length of %s", pathname.get());
+        return nullptr;
+    }
+
+    size_t len = endPos;
     if (fseek(file, 0, SEEK_SET) != 0) {
         pathname = JS_EncodeStringToUTF8(cx, pathnameStr);
         if (!pathname) {
             return nullptr;
         }
         JS_ReportErrorUTF8(cx, "can't seek start of %s", pathname.get());
         return nullptr;
     }
 
     UniqueChars buf(js_pod_malloc<char>(len + 1));
     if (!buf) {
+        JS_ReportErrorUTF8(cx, "out of memory reading %s", pathname.get());
         return nullptr;
     }
 
     size_t cc = fread(buf.get(), 1, len, file);
     if (cc != len) {
         if (ptrdiff_t(cc) < 0) {
             ReportCantOpenErrorUnknownEncoding(cx, pathname.get());
         } else {
--- a/js/src/vm/Runtime.h
+++ b/js/src/vm/Runtime.h
@@ -977,18 +977,19 @@ struct JSRuntime : public js::MallocProv
     // The implementation-defined abstract operation HostResolveImportedModule.
     js::MainThreadData<JS::ModuleResolveHook> moduleResolveHook;
 
     // A hook that implements the abstract operations
     // HostGetImportMetaProperties and HostFinalizeImportMeta.
     js::MainThreadData<JS::ModuleMetadataHook> moduleMetadataHook;
 
     // A hook that implements the abstract operation
-    // HostImportModuleDynamically.
-    js::MainThreadData<JS::ModuleDynamicImportHook> moduleDynamicImportHook;
+    // HostImportModuleDynamically. This is also used to enable/disable dynamic
+    // module import and can accessed by off-thread parsing.
+    mozilla::Atomic<JS::ModuleDynamicImportHook> moduleDynamicImportHook;
 
   public:
 #if defined(JS_BUILD_BINAST)
     js::BinaryASTSupport& binast() {
         return binast_;
     }
   private:
     js::BinaryASTSupport binast_;
--- a/media/libcubeb/README_MOZILLA
+++ b/media/libcubeb/README_MOZILLA
@@ -1,8 +1,8 @@
 The source from this directory was copied from the cubeb
 git repository using the update.sh script.  The only changes
 made were those applied by update.sh and the addition of
 Makefile.in build files for the Mozilla build system.
 
 The cubeb git repository is: git://github.com/kinetiknz/cubeb.git
 
-The git commit ID used was a68892dff73bad5ca2b25008b07d0b06fc850391 (2018-10-19 12:17:40 +0200)
+The git commit ID used was 04d58b66057171d25413498b3a4d0607fd500bb8 (2018-10-24 08:43:52 +1300)
--- a/media/libcubeb/include/cubeb.h
+++ b/media/libcubeb/include/cubeb.h
@@ -626,19 +626,23 @@ CUBEB_EXPORT int cubeb_enumerate_devices
     @retval CUBEB_OK
     @retval CUBEB_ERROR_INVALID_PARAMETER if collection is an invalid pointer */
 CUBEB_EXPORT int cubeb_device_collection_destroy(cubeb * context,
                                                  cubeb_device_collection * collection);
 
 /** Registers a callback which is called when the system detects
     a new device or a device is removed.
     @param context
-    @param devtype device type to include
+    @param devtype device type to include. Different callbacks and user pointers
+           can be registered for each devtype. The hybrid devtype
+           `CUBEB_DEVICE_TYPE_INPUT | CUBEB_DEVICE_TYPE_OUTPUT` is also valid
+           and will register the provided callback and user pointer in both sides.
     @param callback a function called whenever the system device list changes.
-           Passing NULL allow to unregister a function
+           Passing NULL allow to unregister a function. You have to unregister
+           first before you register a new callback.
     @param user_ptr pointer to user specified data which will be present in
            subsequent callbacks.
     @retval CUBEB_ERROR_NOT_SUPPORTED */
 CUBEB_EXPORT int cubeb_register_device_collection_changed(cubeb * context,
                                                           cubeb_device_type devtype,
                                                           cubeb_device_collection_changed_callback callback,
                                                           void * user_ptr);
 
--- a/media/libcubeb/src/cubeb_audiounit.cpp
+++ b/media/libcubeb/src/cubeb_audiounit.cpp
@@ -834,16 +834,17 @@ audiounit_reinit_stream(cubeb_stream * s
       return CUBEB_ERROR;
     }
 
     if (audiounit_setup_stream(stm) != CUBEB_OK) {
       LOG("(%p) Stream reinit failed.", stm);
       if (flags & DEV_INPUT && input_device != 0) {
         // Attempt to re-use the same device-id failed, so attempt again with
         // default input device.
+        audiounit_close_stream(stm);
         if (audiounit_set_device_info(stm, 0, io_side::INPUT) != CUBEB_OK ||
             audiounit_setup_stream(stm) != CUBEB_OK) {
           LOG("(%p) Second stream reinit failed.", stm);
           return CUBEB_ERROR;
         }
       }
     }
 
--- a/old-configure.in
+++ b/old-configure.in
@@ -2050,33 +2050,26 @@ if test "$COMPILE_ENVIRONMENT"; then
     MOZ_GTK3_CFLAGS="-I${_topsrcdir}/widget/gtk/compat-gtk3 $MOZ_GTK3_CFLAGS"
     TK_CFLAGS=$MOZ_GTK3_CFLAGS
     TK_LIBS=$MOZ_GTK3_LIBS
     dnl GDK_VERSION_MIN_REQUIRED is not set here as GDK3 deprecated warnings
     dnl are suppressed by widget/gtk/compat-gtk3/gdk/gdkversionmacros.h.
     AC_DEFINE_UNQUOTED(GDK_VERSION_MAX_ALLOWED,$GDK_VERSION_MAX_ALLOWED)
     GLIB_VERSION_MAX_ALLOWED=GLIB_VERSION_2_32
   fi
-  if test "$MOZ_WIDGET_TOOLKIT" = gtk2; then
-    GLIB_VERSION_MAX_ALLOWED=$GLIB_VERSION_MIN_REQUIRED
-  fi
   if test "$MOZ_ENABLE_GTK"; then
     if test "$MOZ_X11"; then
       GDK_PACKAGES=gdk-x11-2.0
     fi
     AC_DEFINE_UNQUOTED(GLIB_VERSION_MIN_REQUIRED,$GLIB_VERSION_MIN_REQUIRED)
     AC_DEFINE_UNQUOTED(GLIB_VERSION_MAX_ALLOWED,$GLIB_VERSION_MAX_ALLOWED)
 
     PKG_CHECK_MODULES(MOZ_GTK2, gtk+-2.0 >= $GTK2_VERSION gtk+-unix-print-2.0 glib-2.0 >= $GLIB_VERSION gobject-2.0 gio-unix-2.0 $GDK_PACKAGES)
     MOZ_GTK2_CFLAGS="-I${_topsrcdir}/widget/gtk/compat $MOZ_GTK2_CFLAGS"
   fi
-  if test "$MOZ_WIDGET_TOOLKIT" = gtk2; then
-    TK_CFLAGS=$MOZ_GTK2_CFLAGS
-    TK_LIBS=$MOZ_GTK2_LIBS
-  fi
 fi # COMPILE_ENVIRONMENT
 
 AC_SUBST(MOZ_FS_LAYOUT)
 
 dnl ========================================================
 dnl = startup-notification support module
 dnl ========================================================
 
--- a/taskcluster/taskgraph/transforms/job/mozharness_test.py
+++ b/taskcluster/taskgraph/transforms/job/mozharness_test.py
@@ -443,16 +443,17 @@ def mozharness_test_on_script_engine_aut
         'MOZHARNESS_URL': {'task-reference': mozharness_url},
         'MOZILLA_BUILD_URL': {'task-reference': installer_url},
         "MOZ_NO_REMOTE": '1',
         "XPCOM_DEBUG_BREAK": 'warn',
         "NO_FAIL_ON_TEST_ERRORS": '1',
         "MOZ_HIDE_RESULTS_TABLE": '1',
         "MOZ_NODE_PATH": "/usr/local/bin/node",
         'MOZ_AUTOMATION': '1',
+        'WORKING_DIR': '/builds/worker',
         'WORKSPACE': '/builds/worker/workspace',
         'TASKCLUSTER_WORKER_TYPE': job['worker-type'],
     }
 
     # for fetch tasks on mobile
     if 'env' in job['worker'] and 'MOZ_FETCHES' in job['worker']['env']:
         env['MOZ_FETCHES'] = job['worker']['env']['MOZ_FETCHES']
         env['MOZ_FETCHES_DIR'] = job['worker']['env']['MOZ_FETCHES_DIR']
--- a/toolkit/actors/FindBarChild.jsm
+++ b/toolkit/actors/FindBarChild.jsm
@@ -56,18 +56,25 @@ class FindBarChild extends ActorChild {
   onKeypress(event) {
     let {FindBarContent} = this;
 
     if (!FindBarContent.inPassThrough &&
         this.eventMatchesFindShortcut(event)) {
       return FindBarContent.start(event);
     }
 
+    // disable FAYT in about:blank to prevent FAYT opening unexpectedly.
+    let location = this.content.location.href;
+    if (location == "about:blank") {
+      return null;
+    }
+
     if (event.ctrlKey || event.altKey || event.metaKey || event.defaultPrevented ||
-        !BrowserUtils.canFastFind(this.content)) {
+        !BrowserUtils.mimeTypeIsTextBased(this.content.document.contentType) ||
+        !BrowserUtils.canFindInPage(location)) {
       return null;
     }
 
     if (FindBarContent.inPassThrough || FindBarContent.inQuickFind) {
       return FindBarContent.onKeypress(event);
     }
 
     if (event.charCode && BrowserUtils.shouldFastFind(event.target)) {
--- a/toolkit/components/viewconfig/content/config.xul
+++ b/toolkit/components/viewconfig/content/config.xul
@@ -11,17 +11,16 @@
 <window id="config"
         data-l10n-id="config-window"
         aria-describedby="warningTitle warningText"
         xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
         windowtype="Preferences:ConfigManager"
         role="application"
         width="750"
         height="500"
-        disablefastfind="true"
         onunload="onConfigUnload();"
         onload="onConfigLoad();">
 
 <linkset>
   <link rel="localization" href="toolkit/about/aboutConfig.ftl"/>
 </linkset>
 
 <script src="chrome://global/content/config.js"/>
--- a/toolkit/locales/en-US/chrome/mozapps/extensions/extensions.dtd
+++ b/toolkit/locales/en-US/chrome/mozapps/extensions/extensions.dtd
@@ -123,16 +123,11 @@
 <!ENTITY addon.updateAvailable.label          "An update is available">
 <!ENTITY addon.checkingForUpdates.label       "Checking for updates…">
 <!ENTITY addon.releaseNotes.label             "Release Notes:">
 <!ENTITY addon.loadingReleaseNotes.label      "Loading…">
 <!ENTITY addon.errorLoadingReleaseNotes.label "Sorry, but there was an error loading the release notes.">
 
 <!ENTITY addon.createdBy.label                "By ">
 
-<!ENTITY eula.title                           "End-User License Agreement">
-<!ENTITY eula.width                           "560px">
-<!ENTITY eula.height                          "400px">
-<!ENTITY eula.accept                          "Accept and Install…">
-
 <!ENTITY settings.path.button.label           "Browse…">
 
 <!ENTITY setting.learnmore "Learn More…">
--- a/toolkit/locales/en-US/chrome/mozapps/extensions/extensions.properties
+++ b/toolkit/locales/en-US/chrome/mozapps/extensions/extensions.properties
@@ -86,19 +86,16 @@ details.notification.gmpPending=%1$S wil
 
 installFromFile.dialogTitle=Select add-on to install
 installFromFile.filterName=Add-ons
 
 uninstallAddonTooltip=Uninstall this add-on
 enableAddonTooltip=Enable this add-on
 disableAddonTooltip=Disable this add-on
 
-#LOCALIZATION NOTE (eulaHeader) %S is name of the add-on asking the user to agree to the EULA
-eulaHeader=%S requires that you accept the following End User License Agreement before installation can proceed:
-
 type.extension.name=Extensions
 type.themes.name=Themes
 type.locale.name=Languages
 type.plugin.name=Plugins
 type.dictionary.name=Dictionaries
 type.service.name=Services
 type.legacy.name=Legacy Extensions
 type.unsupported.name=Unsupported
--- a/toolkit/modules/BrowserUtils.jsm
+++ b/toolkit/modules/BrowserUtils.jsm
@@ -306,41 +306,26 @@ var BrowserUtils = {
           elt instanceof win.HTMLEmbedElement)
         return false;
     }
 
     return true;
   },
 
   /**
-   * Return true if we can FAYT for this window (could be CPOW):
+   * Returns true if we can show a find bar, including FAYT, for the specified
+   * document location. The location must not be in a blacklist of specific
+   * "about:" pages for which find is disabled.
    *
-   * @param win
-   *        The top level window that is focused
-   *
+   * This can be called from the parent process or from content processes.
    */
-  canFastFind(win) {
-    if (!win)
-      return false;
-
-    if (!this.mimeTypeIsTextBased(win.document.contentType))
-      return false;
-
-    // disable FAYT in about:blank to prevent FAYT opening unexpectedly.
-    let loc = win.location;
-    if (loc.href == "about:blank")
-      return false;
-
-    // disable FAYT in documents that ask for it to be disabled.
-    if ((loc.protocol == "about:" || loc.protocol == "chrome:") &&
-        (win.document.documentElement &&
-         win.document.documentElement.getAttribute("disablefastfind") == "true"))
-      return false;
-
-    return true;
+  canFindInPage(location) {
+    return !location.startsWith("about:addons") &&
+           !location.startsWith("about:config") &&
+           !location.startsWith("about:preferences");
   },
 
   _visibleToolbarsMap: new WeakMap(),
 
   /**
    * Return true if any or a specific toolbar that interacts with the content
    * document is visible.
    *
deleted file mode 100644
--- a/toolkit/mozapps/extensions/content/eula.js
+++ /dev/null
@@ -1,26 +0,0 @@
-// -*- indent-tabs-mode: nil; js-indent-level: 2 -*-
-
-/* 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/. */
-
-"use strict";
-
-/* exported Startup */
-
-ChromeUtils.import("resource://gre/modules/AddonManager.jsm");
-
-function Startup() {
-  var bundle = document.getElementById("extensionsStrings");
-  var addon = window.arguments[0].addon;
-
-  document.documentElement.setAttribute("addontype", addon.type);
-
-  var iconURL = AddonManager.getPreferredIconURL(addon, 48, window);
-  if (iconURL)
-    document.getElementById("icon").src = iconURL;
-
-  var label = document.createTextNode(bundle.getFormattedString("eulaHeader", [addon.name]));
-  document.getElementById("heading").appendChild(label);
-  document.getElementById("eula").value = addon.eula;
-}
deleted file mode 100644
--- a/toolkit/mozapps/extensions/content/eula.xul
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0"?>
-
-<!-- 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/. -->
-
-<?xml-stylesheet href="chrome://global/skin/" type="text/css"?>
-<?xml-stylesheet href="chrome://mozapps/skin/extensions/eula.css" type="text/css"?>
-
-<!DOCTYPE window [
-<!ENTITY % brandDTD SYSTEM "chrome://branding/locale/brand.dtd">
-%brandDTD;
-<!ENTITY % extensionsDTD SYSTEM "chrome://mozapps/locale/extensions/extensions.dtd">
-%extensionsDTD;
-]>
-
-<dialog xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
-        title="&eula.title;" width="&eula.width;" height="&eula.height;"
-        buttons="accept,cancel" buttonlabelaccept="&eula.accept;"
-        ondialogaccept="window.arguments[0].accepted = true"
-        onload="Startup();">
-
-  <script type="application/javascript" src="chrome://mozapps/content/extensions/eula.js"/>
-  
-  <stringbundleset id="extensionsSet">
-    <stringbundle id="extensionsStrings" src="chrome://mozapps/locale/extensions/extensions.properties"/>
-  </stringbundleset>
-
-  <hbox id="heading-container">
-    <image id="icon"/>
-    <label id="heading" flex="1"/>
-  </hbox>
-  
-  <textbox id="eula" multiline="true" readonly="true" flex="1"/>
-</dialog>
--- a/toolkit/mozapps/extensions/content/extensions.xml
+++ b/toolkit/mozapps/extensions/content/extensions.xml
@@ -431,27 +431,16 @@
         ]]></body>
       </method>
 
       <method name="installRemote">
         <body><![CDATA[
           if (this.mControl.getAttribute("remote") != "true")
             return;
 
-          if (this.mControl.mAddon.eula) {
-            var data = {
-              addon: this.mControl.mAddon,
-              accepted: false,
-            };
-            window.openDialog("chrome://mozapps/content/extensions/eula.xul", "_blank",
-                              "chrome,dialog,modal,centerscreen,resizable=no", data);
-            if (!data.accepted)
-              return;
-          }
-
           delete this.mControl.mAddon;
           this.mControl.mInstall = this.mInstall;
           this.mControl.setAttribute("status", "installing");
           let prompt = Services.prefs.getBoolPref("extensions.webextPermissionPrompts", false);
           if (prompt) {
             this.mInstall.promptHandler = info => new Promise((resolve, reject) => {
               // Skip prompts for non-webextensions
               if (!info.addon.userPermissions) {
--- a/toolkit/mozapps/extensions/content/extensions.xul
+++ b/toolkit/mozapps/extensions/content/extensions.xul
@@ -12,18 +12,17 @@
 %brandDTD;
 <!ENTITY % extensionsDTD SYSTEM "chrome://mozapps/locale/extensions/extensions.dtd">
 %extensionsDTD;
 ]>
 
 <page xmlns="http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul"
       xmlns:xhtml="http://www.w3.org/1999/xhtml"
       id="addons-page" data-l10n-id="addons-window"
-      role="application" windowtype="Addons:Manager"
-      disablefastfind="true">
+      role="application" windowtype="Addons:Manager">
 
   <xhtml:link rel="shortcut icon"
               href="chrome://mozapps/skin/extensions/extensionGeneric-16.svg"/>
   <linkset>
     <link rel="localization" href="branding/brand.ftl"/>
     <link rel="localization" href="toolkit/about/aboutAddons.ftl"/>
   </linkset>
 
--- a/toolkit/mozapps/extensions/jar.mn
+++ b/toolkit/mozapps/extensions/jar.mn
@@ -10,14 +10,12 @@ toolkit.jar:
   content/mozapps/extensions/extensions.css                     (content/extensions.css)
   content/mozapps/extensions/extensions.js                      (content/extensions.js)
 * content/mozapps/extensions/extensions.xml                     (content/extensions.xml)
   content/mozapps/extensions/updateinfo.xsl                     (content/updateinfo.xsl)
   content/mozapps/extensions/blocklist.xul                      (content/blocklist.xul)
   content/mozapps/extensions/blocklist.js                       (content/blocklist.js)
   content/mozapps/extensions/blocklist.css                      (content/blocklist.css)
   content/mozapps/extensions/blocklist.xml                      (content/blocklist.xml)
-  content/mozapps/extensions/eula.xul                           (content/eula.xul)
-  content/mozapps/extensions/eula.js                            (content/eula.js)
   content/mozapps/extensions/pluginPrefs.xul                    (content/pluginPrefs.xul)
   content/mozapps/extensions/pluginPrefs.js                     (content/pluginPrefs.js)
   content/mozapps/extensions/OpenH264-license.txt               (content/OpenH264-license.txt)
 #endif
deleted file mode 100644
--- a/toolkit/themes/osx/mozapps/extensions/eula.css
+++ /dev/null
@@ -1,43 +0,0 @@
-/* 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/. */
-
-#icon {
-  list-style-image: url("chrome://mozapps/skin/extensions/extensionGeneric.svg");
-  max-width: 48px;
-  max-height: 48px;
-  margin-inline-end: 6px;
-}
-
-#eula-dialog[addontype="theme"] #icon {
-  list-style-image: url("chrome://mozapps/skin/extensions/themeGeneric.svg");
-}
-
-#eula-dialog[addontype="locale"] #icon {
-  list-style-image: url("chrome://mozapps/skin/extensions/localeGeneric.svg");
-}
-
-#eula-dialog[addontype="plugin"] #icon {
-  list-style-image: url("chrome://mozapps/skin/plugins/pluginGeneric.svg");
-}
-
-#eula-dialog[addontype="dictionary"] #icon {
-  list-style-image: url("chrome://mozapps/skin/extensions/dictionaryGeneric.svg");
-}
-
-#heading-container {
-  -moz-box-align: center;
-}
-
-#heading {
-  font-size: 120%;
-}
-
-#eula {
-  -moz-appearance: none;
-  color: -moz-FieldText;
-  background-color: -moz-Field;
-  margin: 1em;
-  border: 1px solid ActiveBorder;
-}
-
--- a/toolkit/themes/osx/mozapps/jar.mn
+++ b/toolkit/themes/osx/mozapps/jar.mn
@@ -8,15 +8,14 @@ toolkit.jar:
   skin/classic/mozapps/downloads/unknownContentType.css           (downloads/unknownContentType.css)
   skin/classic/mozapps/extensions/discover-logo.png               (extensions/discover-logo.png)
   skin/classic/mozapps/extensions/rating-won.png                  (extensions/rating-won.png)
   skin/classic/mozapps/extensions/rating-not-won.png              (extensions/rating-not-won.png)
   skin/classic/mozapps/extensions/cancel.png                      (extensions/cancel.png)
   skin/classic/mozapps/extensions/toolbarbutton-dropmarker.png    (extensions/toolbarbutton-dropmarker.png)
   skin/classic/mozapps/extensions/heart.png                       (extensions/heart.png)
 * skin/classic/mozapps/extensions/extensions.css                  (extensions/extensions.css)
-  skin/classic/mozapps/extensions/eula.css                        (extensions/eula.css)
   skin/classic/mozapps/extensions/blocklist.css                   (extensions/blocklist.css)
   skin/classic/mozapps/plugins/pluginHelp-16.png                  (plugins/pluginHelp-16.png)
   skin/classic/mozapps/profile/profileSelection.css               (profile/profileSelection.css)
   skin/classic/mozapps/update/buttons.png                         (update/buttons.png)
 * skin/classic/mozapps/update/updates.css                         (update/updates.css)
   skin/classic/mozapps/handling/handling.css                      (handling/handling.css)
--- a/toolkit/themes/shared/non-mac.jar.inc.mn
+++ b/toolkit/themes/shared/non-mac.jar.inc.mn
@@ -34,15 +34,14 @@
 
   skin/classic/mozapps/downloads/downloadButtons.png         (../../windows/mozapps/downloads/downloadButtons.png)
   skin/classic/mozapps/downloads/unknownContentType.css      (../../windows/mozapps/downloads/unknownContentType.css)
   skin/classic/mozapps/extensions/blocklist.css              (../../windows/mozapps/extensions/blocklist.css)
   skin/classic/mozapps/extensions/discover-logo.png          (../../windows/mozapps/extensions/discover-logo.png)
   skin/classic/mozapps/extensions/rating-won.png             (../../windows/mozapps/extensions/rating-won.png)
   skin/classic/mozapps/extensions/rating-not-won.png         (../../windows/mozapps/extensions/rating-not-won.png)
   skin/classic/mozapps/extensions/cancel.png                 (../../windows/mozapps/extensions/cancel.png)
-  skin/classic/mozapps/extensions/eula.css                   (../../windows/mozapps/extensions/eula.css)
   skin/classic/mozapps/handling/handling.css                 (../../windows/mozapps/handling/handling.css)
   skin/classic/mozapps/plugins/pluginHelp-16.png             (../../windows/mozapps/plugins/pluginHelp-16.png)
   skin/classic/mozapps/profile/profileSelection.css          (../../windows/mozapps/profile/profileSelection.css)
   skin/classic/mozapps/update/downloadButtons.png            (../../windows/mozapps/update/downloadButtons.png)
 
 % override chrome://mozapps/skin/xpinstall/xpinstallItemGeneric.png       chrome://mozapps/skin/extensions/extensionGeneric.svg
deleted file mode 100644
--- a/toolkit/themes/windows/mozapps/extensions/eula.css
+++ /dev/null
@@ -1,43 +0,0 @@
-/* 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/. */
-
-#icon {
-  list-style-image: url("chrome://mozapps/skin/extensions/extensionGeneric.svg");
-  max-width: 48px;
-  max-height: 48px;
-  margin-inline-end: 6px;
-}
-
-#eula-dialog[addontype="theme"] #icon {
-  list-style-image: url("chrome://mozapps/skin/extensions/themeGeneric.svg");
-}
-
-#eula-dialog[addontype="locale"] #icon {
-  list-style-image: url("chrome://mozapps/skin/extensions/localeGeneric.svg");
-}
-
-#eula-dialog[addontype="plugin"] #icon {
-  list-style-image: url("chrome://mozapps/skin/plugins/pluginGeneric.svg");
-}
-
-#eula-dialog[addontype="dictionary"] #icon {
-  list-style-image: url("chrome://mozapps/skin/extensions/dictionaryGeneric.svg");
-}
-
-#heading-container {
-  -moz-box-align: center;
-}
-
-#heading {
-  font-size: 120%;
-}
-
-#eula {
-  -moz-appearance: none;
-  color: -moz-FieldText;
-  background-color: -moz-Field;
-  margin: 1em;
-  border: 1px solid ActiveBorder;
-}
-
deleted file mode 100644
--- a/widget/gtk/gtk2drawing.c
+++ /dev/null
@@ -1,3534 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/* 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/. */
-
-/*
- * This file contains painting functions for each of the gtk2 widgets.
- * Adapted from the gtkdrawing.c, and gtk+2.0 source.
- */
-
-#include <gtk/gtk.h>
-#include <gdk/gdkprivate.h>
-#include <string.h>
-#include "gtkdrawing.h"
-#include "mozilla/Assertions.h"
-#include "prinrval.h"
-
-#include <math.h>
-#include <stdbool.h> // for MOZ_ASSERT_UNREACHABLE
-
-#define XTHICKNESS(style) (style->xthickness)
-#define YTHICKNESS(style) (style->ythickness)
-#define WINDOW_IS_MAPPED(window) ((window) && GDK_IS_WINDOW(window) && gdk_window_is_visible(window))
-
-static GtkWidget* gProtoWindow;
-static GtkWidget* gProtoLayout;
-static GtkWidget* gButtonWidget;
-static GtkWidget* gToggleButtonWidget;
-static GtkWidget* gButtonArrowWidget;
-static GtkWidget* gCheckboxWidget;
-static GtkWidget* gRadiobuttonWidget;
-static GtkWidget* gHorizScrollbarWidget;
-static GtkWidget* gVertScrollbarWidget;
-static GtkWidget* gSpinWidget;
-static GtkWidget* gHScaleWidget;
-static GtkWidget* gVScaleWidget;
-static GtkWidget* gEntryWidget;
-static GtkWidget* gComboBoxWidget;
-static GtkWidget* gComboBoxButtonWidget;
-static GtkWidget* gComboBoxArrowWidget;
-static GtkWidget* gComboBoxSeparatorWidget;
-static GtkWidget* gComboBoxEntryWidget;
-static GtkWidget* gComboBoxEntryTextareaWidget;
-static GtkWidget* gComboBoxEntryButtonWidget;
-static GtkWidget* gComboBoxEntryArrowWidget;
-static GtkWidget* gHandleBoxWidget;
-static GtkWidget* gToolbarWidget;
-static GtkWidget* gFrameWidget;
-static GtkWidget* gStatusbarWidget;
-static GtkWidget* gProgressWidget;
-static GtkWidget* gTabWidget;
-static GtkWidget* gTooltipWidget;
-static GtkWidget* gMenuBarWidget;
-static GtkWidget* gMenuBarItemWidget;
-static GtkWidget* gMenuPopupWidget;
-static GtkWidget* gMenuItemWidget;
-static GtkWidget* gCheckMenuItemWidget;
-static GtkWidget* gTreeViewWidget;
-static GtkTreeViewColumn* gMiddleTreeViewColumn;
-static GtkWidget* gTreeHeaderCellWidget;
-static GtkWidget* gTreeHeaderSortArrowWidget;
-static GtkWidget* gExpanderWidget;
-static GtkWidget* gToolbarSeparatorWidget;
-static GtkWidget* gMenuSeparatorWidget;
-static GtkWidget* gHPanedWidget;
-static GtkWidget* gVPanedWidget;
-static GtkWidget* gScrolledWindowWidget;
-
-static gboolean have_arrow_scaling;
-static gboolean is_initialized;
-
-/* Because we have such an unconventional way of drawing widgets, signal to the GTK theme engine
-   that they are drawing for Mozilla instead of a conventional GTK app so they can do any specific
-   things they may want to do. */
-static void
-moz_gtk_set_widget_name(GtkWidget* widget)
-{
-    gtk_widget_set_name(widget, "MozillaGtkWidget");
-}
-
-static gint
-ensure_window_widget()
-{
-    if (!gProtoWindow) {
-        gProtoWindow = gtk_window_new(GTK_WINDOW_POPUP);
-        gtk_widget_realize(gProtoWindow);
-        moz_gtk_set_widget_name(gProtoWindow);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-setup_widget_prototype(GtkWidget* widget)
-{
-    ensure_window_widget();
-    if (!gProtoLayout) {
-        gProtoLayout = gtk_fixed_new();
-        gtk_container_add(GTK_CONTAINER(gProtoWindow), gProtoLayout);
-    }
-
-    gtk_container_add(GTK_CONTAINER(gProtoLayout), widget);
-    gtk_widget_realize(widget);
-    g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_button_widget()
-{
-    if (!gButtonWidget) {
-        gButtonWidget = gtk_button_new_with_label("M");
-        setup_widget_prototype(gButtonWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_hpaned_widget()
-{
-    if (!gHPanedWidget) {
-        gHPanedWidget = gtk_hpaned_new();
-        setup_widget_prototype(gHPanedWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_vpaned_widget()
-{
-    if (!gVPanedWidget) {
-        gVPanedWidget = gtk_vpaned_new();
-        setup_widget_prototype(gVPanedWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_toggle_button_widget()
-{
-    if (!gToggleButtonWidget) {
-        gToggleButtonWidget = gtk_toggle_button_new();
-        setup_widget_prototype(gToggleButtonWidget);
-        /* toggle button must be set active to get the right style on hover. */
-        GTK_TOGGLE_BUTTON(gToggleButtonWidget)->active = TRUE;
-  }
-  return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_button_arrow_widget()
-{
-    if (!gButtonArrowWidget) {
-        ensure_toggle_button_widget();
-
-        gButtonArrowWidget = gtk_arrow_new(GTK_ARROW_DOWN, GTK_SHADOW_OUT);
-        gtk_container_add(GTK_CONTAINER(gToggleButtonWidget), gButtonArrowWidget);
-        gtk_widget_realize(gButtonArrowWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_checkbox_widget()
-{
-    if (!gCheckboxWidget) {
-        gCheckboxWidget = gtk_check_button_new_with_label("M");
-        setup_widget_prototype(gCheckboxWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_radiobutton_widget()
-{
-    if (!gRadiobuttonWidget) {
-        gRadiobuttonWidget = gtk_radio_button_new_with_label(NULL, "M");
-        setup_widget_prototype(gRadiobuttonWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_scrollbar_widget()
-{
-    if (!gVertScrollbarWidget) {
-        gVertScrollbarWidget = gtk_vscrollbar_new(NULL);
-        setup_widget_prototype(gVertScrollbarWidget);
-    }
-    if (!gHorizScrollbarWidget) {
-        gHorizScrollbarWidget = gtk_hscrollbar_new(NULL);
-        setup_widget_prototype(gHorizScrollbarWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_spin_widget()
-{
-  if (!gSpinWidget) {
-    gSpinWidget = gtk_spin_button_new(NULL, 1, 0);
-    setup_widget_prototype(gSpinWidget);
-  }
-  return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_scale_widget()
-{
-  if (!gHScaleWidget) {
-    gHScaleWidget = gtk_hscale_new(NULL);
-    setup_widget_prototype(gHScaleWidget);
-  }
-  if (!gVScaleWidget) {
-    gVScaleWidget = gtk_vscale_new(NULL);
-    setup_widget_prototype(gVScaleWidget);
-  }
-  return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_entry_widget()
-{
-    if (!gEntryWidget) {
-        gEntryWidget = gtk_entry_new();
-        setup_widget_prototype(gEntryWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-/* We need to have pointers to the inner widgets (button, separator, arrow)
- * of the ComboBox to get the correct rendering from theme engines which
- * special cases their look. Since the inner layout can change, we ask GTK
- * to NULL our pointers when they are about to become invalid because the
- * corresponding widgets don't exist anymore. It's the role of
- * g_object_add_weak_pointer().
- * Note that if we don't find the inner widgets (which shouldn't happen), we
- * fallback to use generic "non-inner" widgets, and they don't need that kind
- * of weak pointer since they are explicit children of gProtoWindow and as
- * such GTK holds a strong reference to them. */
-static void
-moz_gtk_get_combo_box_inner_button(GtkWidget *widget, gpointer client_data)
-{
-    if (GTK_IS_TOGGLE_BUTTON(widget)) {
-        gComboBoxButtonWidget = widget;
-        g_object_add_weak_pointer(G_OBJECT(widget),
-                                  (gpointer) &gComboBoxButtonWidget);
-        gtk_widget_realize(widget);
-        g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-    }
-}
-
-static void
-moz_gtk_get_combo_box_button_inner_widgets(GtkWidget *widget,
-                                           gpointer client_data)
-{
-    if (GTK_IS_SEPARATOR(widget)) {
-        gComboBoxSeparatorWidget = widget;
-        g_object_add_weak_pointer(G_OBJECT(widget),
-                                  (gpointer) &gComboBoxSeparatorWidget);
-    } else if (GTK_IS_ARROW(widget)) {
-        gComboBoxArrowWidget = widget;
-        g_object_add_weak_pointer(G_OBJECT(widget),
-                                  (gpointer) &gComboBoxArrowWidget);
-    } else
-        return;
-    gtk_widget_realize(widget);
-    g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-}
-
-static gint
-ensure_combo_box_widgets()
-{
-    GtkWidget* buttonChild;
-
-    if (gComboBoxButtonWidget && gComboBoxArrowWidget)
-        return MOZ_GTK_SUCCESS;
-
-    /* Create a ComboBox if needed */
-    if (!gComboBoxWidget) {
-        gComboBoxWidget = gtk_combo_box_new();
-        setup_widget_prototype(gComboBoxWidget);
-    }
-
-    /* Get its inner Button */
-    gtk_container_forall(GTK_CONTAINER(gComboBoxWidget),
-                         moz_gtk_get_combo_box_inner_button,
-                         NULL);
-
-    if (gComboBoxButtonWidget) {
-        /* Get the widgets inside the Button */
-        buttonChild = GTK_BIN(gComboBoxButtonWidget)->child;
-        if (GTK_IS_HBOX(buttonChild)) {
-            /* appears-as-list = FALSE, cell-view = TRUE; the button
-             * contains an hbox. This hbox is there because the ComboBox
-             * needs to place a cell renderer, a separator, and an arrow in
-             * the button when appears-as-list is FALSE. */
-            gtk_container_forall(GTK_CONTAINER(buttonChild),
-                                 moz_gtk_get_combo_box_button_inner_widgets,
-                                 NULL);
-        } else if(GTK_IS_ARROW(buttonChild)) {
-            /* appears-as-list = TRUE, or cell-view = FALSE;
-             * the button only contains an arrow */
-            gComboBoxArrowWidget = buttonChild;
-            g_object_add_weak_pointer(G_OBJECT(buttonChild), (gpointer)
-                                      &gComboBoxArrowWidget);
-            gtk_widget_realize(gComboBoxArrowWidget);
-            g_object_set_data(G_OBJECT(gComboBoxArrowWidget),
-                              "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-        }
-    } else {
-        /* Shouldn't be reached with current internal gtk implementation; we
-         * use a generic toggle button as last resort fallback to avoid
-         * crashing. */
-        ensure_toggle_button_widget();
-        gComboBoxButtonWidget = gToggleButtonWidget;
-    }
-
-    if (!gComboBoxArrowWidget) {
-        /* Shouldn't be reached with current internal gtk implementation;
-         * we gButtonArrowWidget as last resort fallback to avoid
-         * crashing. */
-        ensure_button_arrow_widget();
-        gComboBoxArrowWidget = gButtonArrowWidget;
-    }
-
-    /* We don't test the validity of gComboBoxSeparatorWidget since there
-     * is none when "appears-as-list" = TRUE or "cell-view" = FALSE; if it
-     * is invalid we just won't paint it. */
-
-    return MOZ_GTK_SUCCESS;
-}
-
-/* We need to have pointers to the inner widgets (entry, button, arrow) of
- * the ComboBoxEntry to get the correct rendering from theme engines which
- * special cases their look. Since the inner layout can change, we ask GTK
- * to NULL our pointers when they are about to become invalid because the
- * corresponding widgets don't exist anymore. It's the role of
- * g_object_add_weak_pointer().
- * Note that if we don't find the inner widgets (which shouldn't happen), we
- * fallback to use generic "non-inner" widgets, and they don't need that kind
- * of weak pointer since they are explicit children of gProtoWindow and as
- * such GTK holds a strong reference to them. */
-static void
-moz_gtk_get_combo_box_entry_inner_widgets(GtkWidget *widget,
-                                          gpointer client_data)
-{
-    if (GTK_IS_TOGGLE_BUTTON(widget)) {
-        gComboBoxEntryButtonWidget = widget;
-        g_object_add_weak_pointer(G_OBJECT(widget),
-                                  (gpointer) &gComboBoxEntryButtonWidget);
-    } else if (GTK_IS_ENTRY(widget)) {
-        gComboBoxEntryTextareaWidget = widget;
-        g_object_add_weak_pointer(G_OBJECT(widget),
-                                  (gpointer) &gComboBoxEntryTextareaWidget);
-    } else
-        return;
-    gtk_widget_realize(widget);
-    g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-}
-
-static void
-moz_gtk_get_combo_box_entry_arrow(GtkWidget *widget, gpointer client_data)
-{
-    if (GTK_IS_ARROW(widget)) {
-        gComboBoxEntryArrowWidget = widget;
-        g_object_add_weak_pointer(G_OBJECT(widget),
-                                  (gpointer) &gComboBoxEntryArrowWidget);
-        gtk_widget_realize(widget);
-        g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-    }
-}
-
-static gint
-ensure_combo_box_entry_widgets()
-{
-    GtkWidget* buttonChild;
-
-    if (gComboBoxEntryTextareaWidget &&
-            gComboBoxEntryButtonWidget &&
-            gComboBoxEntryArrowWidget)
-        return MOZ_GTK_SUCCESS;
-
-    /* Create a ComboBoxEntry if needed */
-    if (!gComboBoxEntryWidget) {
-        gComboBoxEntryWidget = gtk_combo_box_entry_new();
-        setup_widget_prototype(gComboBoxEntryWidget);
-    }
-
-    /* Get its inner Entry and Button */
-    gtk_container_forall(GTK_CONTAINER(gComboBoxEntryWidget),
-                         moz_gtk_get_combo_box_entry_inner_widgets,
-                         NULL);
-
-    if (!gComboBoxEntryTextareaWidget) {
-        ensure_entry_widget();
-        gComboBoxEntryTextareaWidget = gEntryWidget;
-    }
-
-    if (gComboBoxEntryButtonWidget) {
-        /* Get the Arrow inside the Button */
-        buttonChild = GTK_BIN(gComboBoxEntryButtonWidget)->child;
-        if (GTK_IS_HBOX(buttonChild)) {
-            /* appears-as-list = FALSE, cell-view = TRUE; the button
-             * contains an hbox. This hbox is there because ComboBoxEntry
-             * inherits from ComboBox which needs to place a cell renderer,
-             * a separator, and an arrow in the button when appears-as-list
-             * is FALSE. Here the hbox should only contain an arrow, since
-             * a ComboBoxEntry doesn't need all those widgets in the
-             * button. */
-            gtk_container_forall(GTK_CONTAINER(buttonChild),
-                                 moz_gtk_get_combo_box_entry_arrow,
-                                 NULL);
-        } else if(GTK_IS_ARROW(buttonChild)) {
-            /* appears-as-list = TRUE, or cell-view = FALSE;
-             * the button only contains an arrow */
-            gComboBoxEntryArrowWidget = buttonChild;
-            g_object_add_weak_pointer(G_OBJECT(buttonChild), (gpointer)
-                                      &gComboBoxEntryArrowWidget);
-            gtk_widget_realize(gComboBoxEntryArrowWidget);
-            g_object_set_data(G_OBJECT(gComboBoxEntryArrowWidget),
-                              "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-        }
-    } else {
-        /* Shouldn't be reached with current internal gtk implementation;
-         * we use a generic toggle button as last resort fallback to avoid
-         * crashing. */
-        ensure_toggle_button_widget();
-        gComboBoxEntryButtonWidget = gToggleButtonWidget;
-    }
-
-    if (!gComboBoxEntryArrowWidget) {
-        /* Shouldn't be reached with current internal gtk implementation;
-         * we gButtonArrowWidget as last resort fallback to avoid
-         * crashing. */
-        ensure_button_arrow_widget();
-        gComboBoxEntryArrowWidget = gButtonArrowWidget;
-    }
-
-    return MOZ_GTK_SUCCESS;
-}
-
-
-static gint
-ensure_handlebox_widget()
-{
-    if (!gHandleBoxWidget) {
-        gHandleBoxWidget = gtk_handle_box_new();
-        setup_widget_prototype(gHandleBoxWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_toolbar_widget()
-{
-    if (!gToolbarWidget) {
-        ensure_handlebox_widget();
-        gToolbarWidget = gtk_toolbar_new();
-        gtk_container_add(GTK_CONTAINER(gHandleBoxWidget), gToolbarWidget);
-        gtk_widget_realize(gToolbarWidget);
-        g_object_set_data(G_OBJECT(gToolbarWidget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_toolbar_separator_widget()
-{
-    if (!gToolbarSeparatorWidget) {
-        ensure_toolbar_widget();
-        gToolbarSeparatorWidget = GTK_WIDGET(gtk_separator_tool_item_new());
-        setup_widget_prototype(gToolbarSeparatorWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_tooltip_widget()
-{
-    if (!gTooltipWidget) {
-        gTooltipWidget = gtk_window_new(GTK_WINDOW_POPUP);
-        gtk_widget_realize(gTooltipWidget);
-        moz_gtk_set_widget_name(gTooltipWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_tab_widget()
-{
-    if (!gTabWidget) {
-        gTabWidget = gtk_notebook_new();
-        setup_widget_prototype(gTabWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_progress_widget()
-{
-    if (!gProgressWidget) {
-        gProgressWidget = gtk_progress_bar_new();
-        setup_widget_prototype(gProgressWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_statusbar_widget()
-{
-    if (!gStatusbarWidget) {
-      gStatusbarWidget = gtk_statusbar_new();
-      setup_widget_prototype(gStatusbarWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_frame_widget()
-{
-    if (!gFrameWidget) {
-        ensure_statusbar_widget();
-        gFrameWidget = gtk_frame_new(NULL);
-        gtk_container_add(GTK_CONTAINER(gStatusbarWidget), gFrameWidget);
-        gtk_widget_realize(gFrameWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_menu_bar_widget()
-{
-    if (!gMenuBarWidget) {
-        gMenuBarWidget = gtk_menu_bar_new();
-        setup_widget_prototype(gMenuBarWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_menu_bar_item_widget()
-{
-    if (!gMenuBarItemWidget) {
-        ensure_menu_bar_widget();
-        gMenuBarItemWidget = gtk_menu_item_new();
-        gtk_menu_shell_append(GTK_MENU_SHELL(gMenuBarWidget),
-                              gMenuBarItemWidget);
-        gtk_widget_realize(gMenuBarItemWidget);
-        g_object_set_data(G_OBJECT(gMenuBarItemWidget),
-                          "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_menu_popup_widget()
-{
-    if (!gMenuPopupWidget) {
-        ensure_menu_bar_item_widget();
-        gMenuPopupWidget = gtk_menu_new();
-        gtk_menu_item_set_submenu(GTK_MENU_ITEM(gMenuBarItemWidget),
-                                  gMenuPopupWidget);
-        gtk_widget_realize(gMenuPopupWidget);
-        g_object_set_data(G_OBJECT(gMenuPopupWidget),
-                          "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_menu_item_widget()
-{
-    if (!gMenuItemWidget) {
-        ensure_menu_popup_widget();
-        gMenuItemWidget = gtk_menu_item_new_with_label("M");
-        gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),
-                              gMenuItemWidget);
-        gtk_widget_realize(gMenuItemWidget);
-        g_object_set_data(G_OBJECT(gMenuItemWidget),
-                          "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_menu_separator_widget()
-{
-    if (!gMenuSeparatorWidget) {
-        ensure_menu_popup_widget();
-        gMenuSeparatorWidget = gtk_separator_menu_item_new();
-        gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),
-                              gMenuSeparatorWidget);
-        gtk_widget_realize(gMenuSeparatorWidget);
-        g_object_set_data(G_OBJECT(gMenuSeparatorWidget),
-                          "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_check_menu_item_widget()
-{
-    if (!gCheckMenuItemWidget) {
-        ensure_menu_popup_widget();
-        gCheckMenuItemWidget = gtk_check_menu_item_new_with_label("M");
-        gtk_menu_shell_append(GTK_MENU_SHELL(gMenuPopupWidget),
-                              gCheckMenuItemWidget);
-        gtk_widget_realize(gCheckMenuItemWidget);
-        g_object_set_data(G_OBJECT(gCheckMenuItemWidget),
-                          "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_tree_view_widget()
-{
-    if (!gTreeViewWidget) {
-        gTreeViewWidget = gtk_tree_view_new();
-        setup_widget_prototype(gTreeViewWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_tree_header_cell_widget()
-{
-    if(!gTreeHeaderCellWidget) {
-        /*
-         * Some GTK engines paint the first and last cell
-         * of a TreeView header with a highlight.
-         * Since we do not know where our widget will be relative
-         * to the other buttons in the TreeView header, we must
-         * paint it as a button that is between two others,
-         * thus ensuring it is neither the first or last button
-         * in the header.
-         * GTK doesn't give us a way to do this explicitly,
-         * so we must paint with a button that is between two
-         * others.
-         */
-
-        GtkTreeViewColumn* firstTreeViewColumn;
-        GtkTreeViewColumn* lastTreeViewColumn;
-
-        ensure_tree_view_widget();
-
-        /* Create and append our three columns */
-        firstTreeViewColumn = gtk_tree_view_column_new();
-        gtk_tree_view_column_set_title(firstTreeViewColumn, "M");
-        gtk_tree_view_append_column(GTK_TREE_VIEW(gTreeViewWidget), firstTreeViewColumn);
-
-        gMiddleTreeViewColumn = gtk_tree_view_column_new();
-        gtk_tree_view_column_set_title(gMiddleTreeViewColumn, "M");
-        gtk_tree_view_append_column(GTK_TREE_VIEW(gTreeViewWidget),
-                                    gMiddleTreeViewColumn);
-
-        lastTreeViewColumn = gtk_tree_view_column_new();
-        gtk_tree_view_column_set_title(lastTreeViewColumn, "M");
-        gtk_tree_view_append_column(GTK_TREE_VIEW(gTreeViewWidget), lastTreeViewColumn);
-
-        /* Use the middle column's header for our button */
-        gTreeHeaderCellWidget = gMiddleTreeViewColumn->button;
-        gTreeHeaderSortArrowWidget = gMiddleTreeViewColumn->arrow;
-        g_object_set_data(G_OBJECT(gTreeHeaderCellWidget),
-                          "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-        g_object_set_data(G_OBJECT(gTreeHeaderSortArrowWidget),
-                          "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_expander_widget()
-{
-    if (!gExpanderWidget) {
-        gExpanderWidget = gtk_expander_new("M");
-        setup_widget_prototype(gExpanderWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-ensure_scrolled_window_widget()
-{
-    if (!gScrolledWindowWidget) {
-        gScrolledWindowWidget = gtk_scrolled_window_new(NULL, NULL);
-        setup_widget_prototype(gScrolledWindowWidget);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static GtkStateType
-ConvertGtkState(GtkWidgetState* state)
-{
-    if (state->disabled)
-        return GTK_STATE_INSENSITIVE;
-    else if (state->depressed)
-        return (state->inHover ? GTK_STATE_PRELIGHT : GTK_STATE_ACTIVE);
-    else if (state->inHover)
-        return (state->active ? GTK_STATE_ACTIVE : GTK_STATE_PRELIGHT);
-    else
-        return GTK_STATE_NORMAL;
-}
-
-static gint
-TSOffsetStyleGCArray(GdkGC** gcs, gint xorigin, gint yorigin)
-{
-    int i;
-    /* there are 5 gc's in each array, for each of the widget states */
-    for (i = 0; i < 5; ++i)
-        gdk_gc_set_ts_origin(gcs[i], xorigin, yorigin);
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-TSOffsetStyleGCs(GtkStyle* style, gint xorigin, gint yorigin)
-{
-    TSOffsetStyleGCArray(style->fg_gc, xorigin, yorigin);
-    TSOffsetStyleGCArray(style->bg_gc, xorigin, yorigin);
-    TSOffsetStyleGCArray(style->light_gc, xorigin, yorigin);
-    TSOffsetStyleGCArray(style->dark_gc, xorigin, yorigin);
-    TSOffsetStyleGCArray(style->mid_gc, xorigin, yorigin);
-    TSOffsetStyleGCArray(style->text_gc, xorigin, yorigin);
-    TSOffsetStyleGCArray(style->base_gc, xorigin, yorigin);
-    gdk_gc_set_ts_origin(style->black_gc, xorigin, yorigin);
-    gdk_gc_set_ts_origin(style->white_gc, xorigin, yorigin);
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_init()
-{
-    GtkWidgetClass *entry_class;
-
-    if (is_initialized)
-        return MOZ_GTK_SUCCESS;
-
-    is_initialized = TRUE;
-    have_arrow_scaling = (gtk_major_version > 2 ||
-                          (gtk_major_version == 2 && gtk_minor_version >= 12));
-
-    /* Add style property to GtkEntry.
-     * Adding the style property to the normal GtkEntry class means that it
-     * will work without issues inside GtkComboBox and for Spinbuttons. */
-    entry_class = g_type_class_ref(GTK_TYPE_ENTRY);
-    gtk_widget_class_install_style_property(entry_class,
-        g_param_spec_boolean("honors-transparent-bg-hint",
-                             "Transparent BG enabling flag",
-                             "If TRUE, the theme is able to draw the GtkEntry on non-prefilled background.",
-                             FALSE,
-                             G_PARAM_READWRITE));
-
-    return MOZ_GTK_SUCCESS;
-}
-
-GdkColormap*
-moz_gtk_widget_get_colormap()
-{
-    /* Child widgets inherit the colormap from the GtkWindow. */
-    ensure_window_widget();
-    return gtk_widget_get_colormap(gProtoWindow);
-}
-
-gint
-moz_gtk_checkbox_get_metrics(gint* indicator_size, gint* indicator_spacing)
-{
-    ensure_checkbox_widget();
-
-    gtk_widget_style_get (gCheckboxWidget,
-                          "indicator_size", indicator_size,
-                          "indicator_spacing", indicator_spacing,
-                          NULL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_radio_get_metrics(gint* indicator_size, gint* indicator_spacing)
-{
-    ensure_radiobutton_widget();
-
-    gtk_widget_style_get (gRadiobuttonWidget,
-                          "indicator_size", indicator_size,
-                          "indicator_spacing", indicator_spacing,
-                          NULL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_get_focus_outline_size(gint* focus_h_width, gint* focus_v_width)
-{
-    gboolean interior_focus;
-    gint focus_width = 0;
-
-    ensure_entry_widget();
-    gtk_widget_style_get(gEntryWidget,
-                         "interior-focus", &interior_focus,
-                         "focus-line-width", &focus_width,
-                         NULL);
-    if (interior_focus) {
-        *focus_h_width = XTHICKNESS(gEntryWidget->style) + focus_width;
-        *focus_v_width = YTHICKNESS(gEntryWidget->style) + focus_width;
-    } else {
-        *focus_h_width = focus_width;
-        *focus_v_width = focus_width;
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_widget_get_focus(GtkWidget* widget, gboolean* interior_focus,
-                         gint* focus_width, gint* focus_pad) 
-{
-    gtk_widget_style_get (widget,
-                          "interior-focus", interior_focus,
-                          "focus-line-width", focus_width,
-                          "focus-padding", focus_pad,
-                          NULL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_menuitem_get_horizontal_padding(gint* horizontal_padding)
-{
-    ensure_menu_item_widget();
-
-    gtk_widget_style_get (gMenuItemWidget,
-                          "horizontal-padding", horizontal_padding,
-                          NULL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_checkmenuitem_get_horizontal_padding(gint* horizontal_padding)
-{
-    ensure_check_menu_item_widget();
-
-    gtk_widget_style_get (gCheckMenuItemWidget,
-                          "horizontal-padding", horizontal_padding,
-                          NULL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_button_get_default_overflow(gint* border_top, gint* border_left,
-                                    gint* border_bottom, gint* border_right)
-{
-    GtkBorder* default_outside_border;
-
-    ensure_button_widget();
-    gtk_widget_style_get(gButtonWidget,
-                         "default-outside-border", &default_outside_border,
-                         NULL);
-
-    if (default_outside_border) {
-        *border_top = default_outside_border->top;
-        *border_left = default_outside_border->left;
-        *border_bottom = default_outside_border->bottom;
-        *border_right = default_outside_border->right;
-        gtk_border_free(default_outside_border);
-    } else {
-        *border_top = *border_left = *border_bottom = *border_right = 0;
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_button_get_default_border(gint* border_top, gint* border_left,
-                                  gint* border_bottom, gint* border_right)
-{
-    GtkBorder* default_border;
-
-    ensure_button_widget();
-    gtk_widget_style_get(gButtonWidget,
-                         "default-border", &default_border,
-                         NULL);
-
-    if (default_border) {
-        *border_top = default_border->top;
-        *border_left = default_border->left;
-        *border_bottom = default_border->bottom;
-        *border_right = default_border->right;
-        gtk_border_free(default_border);
-    } else {
-        /* see gtkbutton.c */
-        *border_top = *border_left = *border_bottom = *border_right = 1;
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_splitter_get_metrics(gint orientation, gint* size)
-{
-    if (orientation == GTK_ORIENTATION_HORIZONTAL) {
-        ensure_hpaned_widget();
-        gtk_widget_style_get(gHPanedWidget, "handle_size", size, NULL);
-    } else {
-        ensure_vpaned_widget();
-        gtk_widget_style_get(gVPanedWidget, "handle_size", size, NULL);
-    }
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_button_get_inner_border(GtkWidget* widget, GtkBorder* inner_border)
-{
-    static const GtkBorder default_inner_border = { 1, 1, 1, 1 };
-    GtkBorder *tmp_border;
-
-    gtk_widget_style_get (widget, "inner-border", &tmp_border, NULL);
-
-    if (tmp_border) {
-        *inner_border = *tmp_border;
-        gtk_border_free(tmp_border);
-    }
-    else
-        *inner_border = default_inner_border;
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_button_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                     GdkRectangle* cliprect, GtkWidgetState* state,
-                     GtkReliefStyle relief, GtkWidget* widget,
-                     GtkTextDirection direction)
-{
-    GtkShadowType shadow_type;
-    GtkStyle* style = widget->style;
-    GtkStateType button_state = ConvertGtkState(state);
-    gint x = rect->x, y=rect->y, width=rect->width, height=rect->height;
-
-    gboolean interior_focus;
-    gint focus_width, focus_pad;
-
-    moz_gtk_widget_get_focus(widget, &interior_focus, &focus_width, &focus_pad);
-
-    if (WINDOW_IS_MAPPED(drawable)) {
-        gdk_window_set_back_pixmap(drawable, NULL, TRUE);
-        gdk_window_clear_area(drawable, cliprect->x, cliprect->y,
-                              cliprect->width, cliprect->height);
-    }
-
-    gtk_widget_set_state(widget, button_state);
-    gtk_widget_set_direction(widget, direction);
-
-    if (state->isDefault)
-        GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_DEFAULT);
-
-    GTK_BUTTON(widget)->relief = relief;
-
-    /* Some theme engines love to cause us pain in that gtk_paint_focus is a
-       no-op on buttons and button-like widgets. They only listen to this flag. */
-    if (state->focused && !state->disabled)
-        GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
-
-    if (!interior_focus && state->focused) {
-        x += focus_width + focus_pad;
-        y += focus_width + focus_pad;
-        width -= 2 * (focus_width + focus_pad);
-        height -= 2 * (focus_width + focus_pad);
-    }
-
-    shadow_type = button_state == GTK_STATE_ACTIVE ||
-                      state->depressed ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
- 
-    if (state->isDefault && relief == GTK_RELIEF_NORMAL) {
-        /* handle default borders both outside and inside the button */
-        gint default_top, default_left, default_bottom, default_right;
-        moz_gtk_button_get_default_overflow(&default_top, &default_left,
-                                            &default_bottom, &default_right);
-        x -= default_left;
-        y -= default_top;
-        width += default_left + default_right;
-        height += default_top + default_bottom;
-        gtk_paint_box(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_IN, cliprect,
-                      widget, "buttondefault", x, y, width, height);
-
-        moz_gtk_button_get_default_border(&default_top, &default_left,
-                                          &default_bottom, &default_right);
-        x += default_left;
-        y += default_top;
-        width -= (default_left + default_right);
-        height -= (default_top + default_bottom);
-    }
- 
-    if (relief != GTK_RELIEF_NONE || state->depressed ||
-        (button_state != GTK_STATE_NORMAL &&
-         button_state != GTK_STATE_INSENSITIVE)) {
-        TSOffsetStyleGCs(style, x, y);
-        /* the following line can trigger an assertion (Crux theme)
-           file ../../gdk/gdkwindow.c: line 1846 (gdk_window_clear_area):
-           assertion `GDK_IS_WINDOW (window)' failed */
-        gtk_paint_box(style, drawable, button_state, shadow_type, cliprect,
-                      widget, "button", x, y, width, height);
-    }
-
-    if (state->focused) {
-        if (interior_focus) {
-            x += widget->style->xthickness + focus_pad;
-            y += widget->style->ythickness + focus_pad;
-            width -= 2 * (widget->style->xthickness + focus_pad);
-            height -= 2 * (widget->style->ythickness + focus_pad);
-        } else {
-            x -= focus_width + focus_pad;
-            y -= focus_width + focus_pad;
-            width += 2 * (focus_width + focus_pad);
-            height += 2 * (focus_width + focus_pad);
-        }
-
-        TSOffsetStyleGCs(style, x, y);
-        gtk_paint_focus(style, drawable, button_state, cliprect,
-                        widget, "button", x, y, width, height);
-    }
-
-    GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_DEFAULT);
-    GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_toggle_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                     GdkRectangle* cliprect, GtkWidgetState* state,
-                     gboolean selected, gboolean inconsistent,
-                     gboolean isradio, GtkTextDirection direction)
-{
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkShadowType shadow_type = (selected)?GTK_SHADOW_IN:GTK_SHADOW_OUT;
-    gint indicator_size, indicator_spacing;
-    gint x, y, width, height;
-    gint focus_x, focus_y, focus_width, focus_height;
-    GtkWidget *w;
-    GtkStyle *style;
-
-    if (isradio) {
-        moz_gtk_radio_get_metrics(&indicator_size, &indicator_spacing);
-        w = gRadiobuttonWidget;
-    } else {
-        moz_gtk_checkbox_get_metrics(&indicator_size, &indicator_spacing);
-        w = gCheckboxWidget;
-    }
-
-    // Clamp the rect and paint it center aligned in the rect.
-    x = rect->x;
-    y = rect->y;
-    width = rect->width;
-    height = rect->height;
-
-    if (rect->width < rect->height) {
-      y = rect->y + (rect->height - rect->width) / 2;
-      height = rect->width;
-    }
-
-    if (rect->height < rect->width) {
-      x = rect->x + (rect->width - rect->height) / 2;
-      width = rect->height;
-    }
-
-    focus_x = x - indicator_spacing;
-    focus_y = y - indicator_spacing;
-    focus_width = width + 2 * indicator_spacing;
-    focus_height = height + 2 * indicator_spacing;
-  
-    style = w->style;
-    TSOffsetStyleGCs(style, x, y);
-
-    gtk_widget_set_sensitive(w, !state->disabled);
-    gtk_widget_set_direction(w, direction);
-    GTK_TOGGLE_BUTTON(w)->active = selected;
-      
-    if (isradio) {
-        gtk_paint_option(style, drawable, state_type, shadow_type, cliprect,
-                         gRadiobuttonWidget, "radiobutton", x, y,
-                         width, height);
-        if (state->focused) {
-            gtk_paint_focus(style, drawable, GTK_STATE_ACTIVE, cliprect,
-                            gRadiobuttonWidget, "radiobutton", focus_x, focus_y,
-                            focus_width, focus_height);
-        }
-    }
-    else {
-       /*
-        * 'indeterminate' type on checkboxes. In GTK, the shadow type
-        * must also be changed for the state to be drawn.
-        */
-        if (inconsistent) {
-            gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(gCheckboxWidget), TRUE);
-            shadow_type = GTK_SHADOW_ETCHED_IN;
-        } else {
-            gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON(gCheckboxWidget), FALSE);
-        }
-
-        gtk_paint_check(style, drawable, state_type, shadow_type, cliprect, 
-                        gCheckboxWidget, "checkbutton", x, y, width, height);
-        if (state->focused) {
-            gtk_paint_focus(style, drawable, GTK_STATE_ACTIVE, cliprect,
-                            gCheckboxWidget, "checkbutton", focus_x, focus_y,
-                            focus_width, focus_height);
-        }
-    }
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-calculate_button_inner_rect(GtkWidget* button, GdkRectangle* rect,
-                            GdkRectangle* inner_rect,
-                            GtkTextDirection direction,
-                            gboolean ignore_focus)
-{
-    GtkBorder inner_border;
-    gboolean interior_focus;
-    gint focus_width, focus_pad;
-    GtkStyle* style;
-
-    style = button->style;
-
-    /* This mirrors gtkbutton's child positioning */
-    moz_gtk_button_get_inner_border(button, &inner_border);
-    moz_gtk_widget_get_focus(button, &interior_focus,
-                             &focus_width, &focus_pad);
-
-    if (ignore_focus)
-        focus_width = focus_pad = 0;
-
-    inner_rect->x = rect->x + XTHICKNESS(style) + focus_width + focus_pad;
-    inner_rect->x += direction == GTK_TEXT_DIR_LTR ?
-                        inner_border.left : inner_border.right;
-    inner_rect->y = rect->y + inner_border.top + YTHICKNESS(style) +
-                    focus_width + focus_pad;
-    inner_rect->width = MAX(1, rect->width - inner_border.left -
-       inner_border.right - (XTHICKNESS(style) + focus_pad + focus_width) * 2);
-    inner_rect->height = MAX(1, rect->height - inner_border.top -
-       inner_border.bottom - (YTHICKNESS(style) + focus_pad + focus_width) * 2);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-calculate_arrow_rect(GtkWidget* arrow, GdkRectangle* rect,
-                     GdkRectangle* arrow_rect, GtkTextDirection direction)
-{
-    /* defined in gtkarrow.c */
-    gfloat arrow_scaling = 0.7;
-    gfloat xalign, xpad;
-    gint extent;
-    GtkMisc* misc = GTK_MISC(arrow);
-
-    if (have_arrow_scaling)
-        gtk_widget_style_get(arrow, "arrow_scaling", &arrow_scaling, NULL);
-
-    extent = MIN((rect->width - misc->xpad * 2),
-                 (rect->height - misc->ypad * 2)) * arrow_scaling;
-
-    xalign = direction == GTK_TEXT_DIR_LTR ? misc->xalign : 1.0 - misc->xalign;
-    xpad = misc->xpad + (rect->width - extent) * xalign;
-
-    arrow_rect->x = direction == GTK_TEXT_DIR_LTR ?
-                        floor(rect->x + xpad) : ceil(rect->x + xpad);
-    arrow_rect->y = floor(rect->y + misc->ypad +
-                          ((rect->height - extent) * misc->yalign));
-
-    arrow_rect->width = arrow_rect->height = extent;
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_scrollbar_button_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                               GdkRectangle* cliprect, GtkWidgetState* state,
-                               GtkScrollbarButtonFlags flags,
-                               GtkTextDirection direction)
-{
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkShadowType shadow_type = (state->active) ?
-        GTK_SHADOW_IN : GTK_SHADOW_OUT;
-    GdkRectangle arrow_rect;
-    GtkStyle* style;
-    GtkWidget *scrollbar;
-    GtkArrowType arrow_type;
-    gint arrow_displacement_x, arrow_displacement_y;
-    const char* detail = (flags & MOZ_GTK_STEPPER_VERTICAL) ?
-                           "vscrollbar" : "hscrollbar";
-
-    ensure_scrollbar_widget();
-
-    if (flags & MOZ_GTK_STEPPER_VERTICAL)
-        scrollbar = gVertScrollbarWidget;
-    else
-        scrollbar = gHorizScrollbarWidget;
-
-    gtk_widget_set_direction(scrollbar, direction);
-
-    /* Some theme engines (i.e., ClearLooks) check the scrollbar's allocation
-       to determine where it should paint rounded corners on the buttons.
-       We need to trick them into drawing the buttons the way we want them. */
-
-    scrollbar->allocation.x = rect->x;
-    scrollbar->allocation.y = rect->y;
-    scrollbar->allocation.width = rect->width;
-    scrollbar->allocation.height = rect->height;
-
-    if (flags & MOZ_GTK_STEPPER_VERTICAL) {
-        scrollbar->allocation.height *= 5;
-        if (flags & MOZ_GTK_STEPPER_DOWN) {
-            arrow_type = GTK_ARROW_DOWN;
-            if (flags & MOZ_GTK_STEPPER_BOTTOM)
-                scrollbar->allocation.y -= 4 * rect->height;
-            else
-                scrollbar->allocation.y -= rect->height;
-
-        } else {
-            arrow_type = GTK_ARROW_UP;
-            if (flags & MOZ_GTK_STEPPER_BOTTOM)
-                scrollbar->allocation.y -= 3 * rect->height;
-        }
-    } else {
-        scrollbar->allocation.width *= 5;
-        if (flags & MOZ_GTK_STEPPER_DOWN) {
-            arrow_type = GTK_ARROW_RIGHT;
-            if (flags & MOZ_GTK_STEPPER_BOTTOM)
-                scrollbar->allocation.x -= 4 * rect->width;
-            else
-                scrollbar->allocation.x -= rect->width;
-        } else {
-            arrow_type = GTK_ARROW_LEFT;
-            if (flags & MOZ_GTK_STEPPER_BOTTOM)
-                scrollbar->allocation.x -= 3 * rect->width;
-        }
-    }
-
-    style = scrollbar->style;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    gtk_paint_box(style, drawable, state_type, shadow_type, cliprect,
-                  scrollbar, detail, rect->x, rect->y,
-                  rect->width, rect->height);
-
-    arrow_rect.width = rect->width / 2;
-    arrow_rect.height = rect->height / 2;
-    arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2;
-    arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2;
-
-    if (state_type == GTK_STATE_ACTIVE) {
-        gtk_widget_style_get(scrollbar,
-                             "arrow-displacement-x", &arrow_displacement_x,
-                             "arrow-displacement-y", &arrow_displacement_y,
-                             NULL);
-
-        arrow_rect.x += arrow_displacement_x;
-        arrow_rect.y += arrow_displacement_y;
-    }
-
-    gtk_paint_arrow(style, drawable, state_type, shadow_type, cliprect,
-                    scrollbar, detail, arrow_type, TRUE, arrow_rect.x,
-                    arrow_rect.y, arrow_rect.width, arrow_rect.height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_scrollbar_trough_paint(WidgetNodeType widget,
-                               GdkDrawable* drawable, GdkRectangle* rect,
-                               GdkRectangle* cliprect, GtkWidgetState* state,
-                               GtkTextDirection direction)
-{
-    GtkStyle* style;
-    GtkScrollbar *scrollbar;
-
-    ensure_scrollbar_widget();
-
-    if (widget ==  MOZ_GTK_SCROLLBAR_HORIZONTAL)
-        scrollbar = GTK_SCROLLBAR(gHorizScrollbarWidget);
-    else
-        scrollbar = GTK_SCROLLBAR(gVertScrollbarWidget);
-
-    gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction);
-
-    style = GTK_WIDGET(scrollbar)->style;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_style_apply_default_background(style, drawable, TRUE, GTK_STATE_ACTIVE,
-                                       cliprect, rect->x, rect->y,
-                                       rect->width, rect->height);
-
-    gtk_paint_box(style, drawable, GTK_STATE_ACTIVE, GTK_SHADOW_IN, cliprect,
-                  GTK_WIDGET(scrollbar), "trough", rect->x, rect->y,
-                  rect->width, rect->height);
-
-    if (state->focused) {
-        gtk_paint_focus(style, drawable, GTK_STATE_ACTIVE, cliprect,
-                        GTK_WIDGET(scrollbar), "trough",
-                        rect->x, rect->y, rect->width, rect->height);
-    }
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_scrollbar_thumb_paint(WidgetNodeType widget,
-                              GdkDrawable* drawable, GdkRectangle* rect,
-                              GdkRectangle* cliprect, GtkWidgetState* state,
-                              GtkTextDirection direction)
-{
-    GtkStateType state_type = (state->inHover || state->active) ?
-        GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
-    GtkShadowType shadow_type = GTK_SHADOW_OUT;
-    GtkStyle* style;
-    GtkScrollbar *scrollbar;
-    GtkAdjustment *adj;
-    gboolean activate_slider;
-
-    ensure_scrollbar_widget();
-
-    if (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL)
-        scrollbar = GTK_SCROLLBAR(gHorizScrollbarWidget);
-    else
-        scrollbar = GTK_SCROLLBAR(gVertScrollbarWidget);
-
-    gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction);
-
-    /* Make sure to set the scrollbar range before painting so that
-       everything is drawn properly.  At least the bluecurve (and
-       maybe other) themes don't draw the top or bottom black line
-       surrounding the scrollbar if the theme thinks that it's butted
-       up against the scrollbar arrows.  Note the increases of the
-       clip rect below. */
-    adj = gtk_range_get_adjustment(GTK_RANGE(scrollbar));
-
-    if (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) {
-        adj->page_size = rect->width;
-    }
-    else {
-        adj->page_size = rect->height;
-    }
-
-    adj->lower = 0;
-    adj->value = state->curpos;
-    adj->upper = state->maxpos;
-    gtk_adjustment_changed(adj);
-
-    style = GTK_WIDGET(scrollbar)->style;
-    
-    gtk_widget_style_get(GTK_WIDGET(scrollbar), "activate-slider",
-                         &activate_slider, NULL);
-    
-    if (activate_slider && state->active) {
-        shadow_type = GTK_SHADOW_IN;
-        state_type = GTK_STATE_ACTIVE;
-    }
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    gtk_paint_slider(style, drawable, state_type, shadow_type, cliprect,
-                     GTK_WIDGET(scrollbar), "slider", rect->x, rect->y,
-                     rect->width,  rect->height,
-                     (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) ?
-                     GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_inner_spin_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                         GtkWidgetState* state,
-                         GtkTextDirection direction)
-{
-    GdkRectangle arrow_rect;
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkShadowType shadow_type = state_type == GTK_STATE_ACTIVE ?
-                                  GTK_SHADOW_IN : GTK_SHADOW_OUT;
-    GtkStyle* style;
-
-    ensure_spin_widget();
-    style = gSpinWidget->style;
-    gtk_widget_set_direction(gSpinWidget, direction);
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_paint_box(style, drawable, state_type, shadow_type, NULL, gSpinWidget,
-                  "spinbutton", rect->x, rect->y, rect->width, rect->height);
-
-    /* hard code these values */
-    arrow_rect.width = 6;
-    arrow_rect.height = 6;
-
-    // align spin to the left
-    arrow_rect.x = rect->x;
-
-    // up button
-    arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2 - 3;
-    gtk_paint_arrow(style, drawable, state_type, shadow_type, NULL,
-                    gSpinWidget, "spinbutton",
-                    GTK_ARROW_UP, TRUE,
-                    arrow_rect.x, arrow_rect.y,
-                    arrow_rect.width, arrow_rect.height);
-
-    // down button
-    arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2 + 3;
-    gtk_paint_arrow(style, drawable, state_type, shadow_type, NULL,
-                    gSpinWidget, "spinbutton",
-                    GTK_ARROW_DOWN,
-                    arrow_rect.x, arrow_rect.y,
-                    arrow_rect.width, arrow_rect.height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_spin_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                   GtkTextDirection direction)
-{
-    GtkStyle* style;
-
-    ensure_spin_widget();
-    gtk_widget_set_direction(gSpinWidget, direction);
-    style = gSpinWidget->style;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_paint_box(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_IN, NULL,
-                  gSpinWidget, "spinbutton",
-                  rect->x, rect->y, rect->width, rect->height);
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_spin_updown_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                          gboolean isDown, GtkWidgetState* state,
-                          GtkTextDirection direction)
-{
-    GdkRectangle arrow_rect;
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkShadowType shadow_type = state_type == GTK_STATE_ACTIVE ?
-                                  GTK_SHADOW_IN : GTK_SHADOW_OUT;
-    GtkStyle* style;
-
-    ensure_spin_widget();
-    style = gSpinWidget->style;
-    gtk_widget_set_direction(gSpinWidget, direction);
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_paint_box(style, drawable, state_type, shadow_type, NULL, gSpinWidget,
-                  isDown ? "spinbutton_down" : "spinbutton_up",
-                  rect->x, rect->y, rect->width, rect->height);
-
-    /* hard code these values */
-    arrow_rect.width = 6;
-    arrow_rect.height = 6;
-    arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2;
-    arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2;
-    arrow_rect.y += isDown ? -1 : 1;
-
-    gtk_paint_arrow(style, drawable, state_type, shadow_type, NULL,
-                    gSpinWidget, "spinbutton",
-                    isDown ? GTK_ARROW_DOWN : GTK_ARROW_UP, TRUE,
-                    arrow_rect.x, arrow_rect.y,
-                    arrow_rect.width, arrow_rect.height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_scale_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                    GdkRectangle* cliprect, GtkWidgetState* state,
-                    GtkOrientation flags, GtkTextDirection direction)
-{
-  gint x = 0, y = 0;
-  GtkStateType state_type = ConvertGtkState(state);
-  GtkStyle* style;
-  GtkWidget* widget;
-
-  ensure_scale_widget();
-  widget = ((flags == GTK_ORIENTATION_HORIZONTAL) ? gHScaleWidget : gVScaleWidget);
-  gtk_widget_set_direction(widget, direction);
-
-  style = widget->style;
-
-  if (flags == GTK_ORIENTATION_HORIZONTAL) {
-    x = XTHICKNESS(style);
-    y++;
-  }
-  else {
-    x++;
-    y = YTHICKNESS(style);
-  }
-
-  TSOffsetStyleGCs(style, rect->x, rect->y);
-
-  gtk_paint_box(style, drawable, GTK_STATE_ACTIVE, GTK_SHADOW_IN, cliprect,
-                widget, "trough", rect->x + x, rect->y + y,
-                rect->width - 2*x, rect->height - 2*y);
-
-  if (state->focused)
-    gtk_paint_focus(style, drawable, state_type, cliprect, widget, "trough",
-                    rect->x, rect->y, rect->width, rect->height);
-
-  return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_scale_thumb_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                          GdkRectangle* cliprect, GtkWidgetState* state,
-                          GtkOrientation flags, GtkTextDirection direction)
-{
-  GtkStateType state_type = ConvertGtkState(state);
-  GtkStyle* style;
-  GtkWidget* widget;
-  gint thumb_width, thumb_height, x, y;
-
-  ensure_scale_widget();
-  widget = ((flags == GTK_ORIENTATION_HORIZONTAL) ? gHScaleWidget : gVScaleWidget);
-  gtk_widget_set_direction(widget, direction);
-
-  style = widget->style;
-
-  /* determine the thumb size, and position the thumb in the center in the opposite axis */
-  if (flags == GTK_ORIENTATION_HORIZONTAL) {
-    moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_HORIZONTAL, &thumb_width, &thumb_height);
-    x = rect->x;
-    y = rect->y + (rect->height - thumb_height) / 2;
-  }
-  else {
-    moz_gtk_get_scalethumb_metrics(GTK_ORIENTATION_VERTICAL, &thumb_height, &thumb_width);
-    x = rect->x + (rect->width - thumb_width) / 2;
-    y = rect->y;
-  }
-
-  TSOffsetStyleGCs(style, rect->x, rect->y);
-  gtk_paint_slider(style, drawable, state_type, GTK_SHADOW_OUT, cliprect,
-                   widget, (flags == GTK_ORIENTATION_HORIZONTAL) ? "hscale" : "vscale",
-                   x, y, thumb_width, thumb_height, flags);
-
-  return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_gripper_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                      GdkRectangle* cliprect, GtkWidgetState* state,
-                      GtkTextDirection direction)
-{
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkShadowType shadow_type;
-    GtkStyle* style;
-
-    ensure_handlebox_widget();
-    gtk_widget_set_direction(gHandleBoxWidget, direction);
-
-    style = gHandleBoxWidget->style;
-    shadow_type = GTK_HANDLE_BOX(gHandleBoxWidget)->shadow_type;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_paint_box(style, drawable, state_type, shadow_type, cliprect,
-                  gHandleBoxWidget, "handlebox_bin", rect->x, rect->y,
-                  rect->width, rect->height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_hpaned_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                     GdkRectangle* cliprect, GtkWidgetState* state)
-{
-    GtkStateType hpaned_state = ConvertGtkState(state);
-
-    ensure_hpaned_widget();
-    gtk_paint_handle(gHPanedWidget->style, drawable, hpaned_state,
-                     GTK_SHADOW_NONE, cliprect, gHPanedWidget, "paned",
-                     rect->x, rect->y, rect->width, rect->height,
-                     GTK_ORIENTATION_VERTICAL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_vpaned_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                     GdkRectangle* cliprect, GtkWidgetState* state)
-{
-    GtkStateType vpaned_state = ConvertGtkState(state);
-
-    ensure_vpaned_widget();
-    gtk_paint_handle(gVPanedWidget->style, drawable, vpaned_state,
-                     GTK_SHADOW_NONE, cliprect, gVPanedWidget, "paned",
-                     rect->x, rect->y, rect->width, rect->height,
-                     GTK_ORIENTATION_HORIZONTAL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_entry_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                    GdkRectangle* cliprect, GtkWidgetState* state,
-                    GtkWidget* widget, GtkTextDirection direction)
-{
-    GtkStateType bg_state = state->disabled ?
-                                GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL;
-    gint x, y, width = rect->width, height = rect->height;
-    GtkStyle* style;
-    gboolean interior_focus;
-    gboolean theme_honors_transparency = FALSE;
-    gint focus_width;
-    int draw_focus_outline_only = state->depressed; // NS_THEME_FOCUS_OUTLINE
-
-    gtk_widget_set_direction(widget, direction);
-
-    style = widget->style;
-
-    gtk_widget_style_get(widget,
-                         "interior-focus", &interior_focus,
-                         "focus-line-width", &focus_width,
-                         "honors-transparent-bg-hint", &theme_honors_transparency,
-                         NULL);
-
-    if (draw_focus_outline_only) {
-        // Inflate the given 'rect' with the focus outline size.
-        gint h, v;
-        moz_gtk_get_focus_outline_size(&h, &v);
-        rect->x -= h;
-        rect->width += 2 * h;
-        rect->y -= v;
-        rect->height += 2 * v;
-        width = rect->width;
-        height = rect->height;
-    }
-
-    /* gtkentry.c uses two windows, one for the entire widget and one for the
-     * text area inside it. The background of both windows is set to the "base"
-     * color of the new state in gtk_entry_state_changed, but only the inner
-     * textarea window uses gtk_paint_flat_box when exposed */
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    /* This gets us a lovely greyish disabledish look */
-    gtk_widget_set_sensitive(widget, !state->disabled);
-
-    /* GTK fills the outer widget window with the base color before drawing the widget.
-     * Some older themes rely on this behavior, but many themes nowadays use rounded
-     * corners on their widgets. While most GTK apps are blissfully unaware of this
-     * problem due to their use of the default window background, we render widgets on
-     * many kinds of backgrounds on the web.
-     * If the theme is able to cope with transparency, then we can skip pre-filling
-     * and notify the theme it will paint directly on the canvas. */
-    if (theme_honors_transparency) {
-        g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(TRUE));
-    } else {
-        GdkRectangle clipped_rect;
-        gdk_rectangle_intersect(rect, cliprect, &clipped_rect);
-        if (clipped_rect.width != 0) {
-            gdk_draw_rectangle(drawable, style->base_gc[bg_state], TRUE,
-                               clipped_rect.x, clipped_rect.y,
-                               clipped_rect.width, clipped_rect.height);
-        }
-        g_object_set_data(G_OBJECT(widget), "transparent-bg-hint", GINT_TO_POINTER(FALSE));
-    }
-
-    if (!draw_focus_outline_only) {
-        /* Get the position of the inner window, see _gtk_entry_get_borders */
-        x = XTHICKNESS(style);
-        y = YTHICKNESS(style);
-
-        if (!interior_focus) {
-            x += focus_width;
-            y += focus_width;
-        }
-
-        /* Simulate an expose of the inner window */
-        gtk_paint_flat_box(style, drawable, bg_state, GTK_SHADOW_NONE,
-                           cliprect, widget, "entry_bg",  rect->x + x,
-                           rect->y + y, rect->width - 2*x, rect->height - 2*y);
-    }
-
-    /* Now paint the shadow and focus border.
-     * We do like in gtk_entry_draw_frame, we first draw the shadow, a tad
-     * smaller when focused if the focus is not interior, then the focus. */
-    x = rect->x;
-    y = rect->y;
-
-    if (state->focused && !state->disabled) {
-        /* This will get us the lit borders that focused textboxes enjoy on
-         * some themes. */
-        GTK_WIDGET_SET_FLAGS(widget, GTK_HAS_FOCUS);
-
-        if (!interior_focus) {
-            /* Indent the border a little bit if we have exterior focus 
-               (this is what GTK does to draw native entries) */
-            x += focus_width;
-            y += focus_width;
-            width -= 2 * focus_width;
-            height -= 2 * focus_width;
-        }
-    }
-
-    if (!draw_focus_outline_only || interior_focus) {
-        gtk_paint_shadow(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_IN,
-                         cliprect, widget, "entry", x, y, width, height);
-    }
-
-    if (state->focused && !state->disabled) {
-        if (!interior_focus) {
-            gtk_paint_focus(style, drawable,  GTK_STATE_NORMAL, cliprect,
-                            widget, "entry",
-                            rect->x, rect->y, rect->width, rect->height);
-        }
-
-        /* Now unset the focus flag. We don't want other entries to look
-         * like they're focused too! */
-        GTK_WIDGET_UNSET_FLAGS(widget, GTK_HAS_FOCUS);
-    }
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint 
-moz_gtk_treeview_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                       GdkRectangle* cliprect, GtkWidgetState* state,
-                       GtkTextDirection direction)
-{
-    gint xthickness, ythickness;
-
-    GtkStyle *style;
-    GtkStateType state_type;
-
-    ensure_tree_view_widget();
-    ensure_scrolled_window_widget();
-
-    gtk_widget_set_direction(gTreeViewWidget, direction);
-    gtk_widget_set_direction(gScrolledWindowWidget, direction);
-
-    /* only handle disabled and normal states, otherwise the whole background
-     * area will be painted differently with other states */
-    state_type = state->disabled ? GTK_STATE_INSENSITIVE : GTK_STATE_NORMAL;
-
-    /* In GTK the treeview sets the background of the window
-     * which contains the cells to the treeview base color.
-     * If we don't set it here the background color will not be correct.*/
-    gtk_widget_modify_bg(gTreeViewWidget, state_type,
-                         &gTreeViewWidget->style->base[state_type]);
-
-    style = gScrolledWindowWidget->style;
-    xthickness = XTHICKNESS(style);
-    ythickness = YTHICKNESS(style);
-
-    TSOffsetStyleGCs(gTreeViewWidget->style, rect->x, rect->y);
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    gtk_paint_flat_box(gTreeViewWidget->style, drawable, state_type,
-                       GTK_SHADOW_NONE, cliprect, gTreeViewWidget, "treeview",
-                       rect->x + xthickness, rect->y + ythickness,
-                       rect->width - 2 * xthickness,
-                       rect->height - 2 * ythickness);
-
-    gtk_paint_shadow(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_IN,
-                     cliprect, gScrolledWindowWidget, "scrolled_window",
-                     rect->x, rect->y, rect->width, rect->height); 
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_tree_header_cell_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                               GdkRectangle* cliprect, GtkWidgetState* state,
-                               gboolean isSorted, GtkTextDirection direction)
-{
-    gtk_tree_view_column_set_sort_indicator(gMiddleTreeViewColumn,
-                                            isSorted);
-
-    moz_gtk_button_paint(drawable, rect, cliprect, state, GTK_RELIEF_NORMAL,
-                         gTreeHeaderCellWidget, direction);
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_tree_header_sort_arrow_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                                     GdkRectangle* cliprect,
-                                     GtkWidgetState* state, GtkArrowType flags,
-                                     GtkTextDirection direction)
-{
-    GdkRectangle arrow_rect;
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkShadowType shadow_type = GTK_SHADOW_IN;
-    GtkArrowType arrow_type = flags;
-    GtkStyle* style;
-
-    ensure_tree_header_cell_widget();
-    gtk_widget_set_direction(gTreeHeaderSortArrowWidget, direction);
-
-    /* hard code these values */
-    arrow_rect.width = 11;
-    arrow_rect.height = 11;
-    arrow_rect.x = rect->x + (rect->width - arrow_rect.width) / 2;
-    arrow_rect.y = rect->y + (rect->height - arrow_rect.height) / 2;
-
-    style = gTreeHeaderSortArrowWidget->style;
-    TSOffsetStyleGCs(style, arrow_rect.x, arrow_rect.y);
-
-    gtk_paint_arrow(style, drawable, state_type, shadow_type, cliprect,
-                    gTreeHeaderSortArrowWidget, "arrow",  arrow_type, TRUE,
-                    arrow_rect.x, arrow_rect.y,
-                    arrow_rect.width, arrow_rect.height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_treeview_expander_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                                GdkRectangle* cliprect, GtkWidgetState* state,
-                                GtkExpanderStyle expander_state,
-                                GtkTextDirection direction)
-{
-    GtkStyle *style;
-    GtkStateType state_type;
-
-    ensure_tree_view_widget();
-    gtk_widget_set_direction(gTreeViewWidget, direction);
-
-    style = gTreeViewWidget->style;
-
-    /* Because the frame we get is of the entire treeview, we can't get the precise
-     * event state of one expander, thus rendering hover and active feedback useless. */
-    state_type = state->disabled ? GTK_STATE_INSENSITIVE :
-                 state->inHover  ? GTK_STATE_PRELIGHT :
-                 state->selected ? GTK_STATE_SELECTED :
-                                   GTK_STATE_NORMAL;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_paint_expander(style, drawable, state_type, cliprect, gTreeViewWidget, "treeview",
-                       rect->x + rect->width / 2, rect->y + rect->height / 2, expander_state);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_combo_box_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                        GdkRectangle* cliprect, GtkWidgetState* state,
-                        gboolean ishtml, GtkTextDirection direction)
-{
-    GdkRectangle arrow_rect, real_arrow_rect;
-    gint separator_width;
-    gboolean wide_separators;
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkShadowType shadow_type = state->active ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
-    GtkStyle* style;
-    GtkRequisition arrow_req;
-
-    ensure_combo_box_widgets();
-
-    /* Also sets the direction on gComboBoxButtonWidget, which is then
-     * inherited by the separator and arrow */
-    moz_gtk_button_paint(drawable, rect, cliprect, state, GTK_RELIEF_NORMAL,
-                         gComboBoxButtonWidget, direction);
-
-    calculate_button_inner_rect(gComboBoxButtonWidget,
-                                rect, &arrow_rect, direction, ishtml);
-    /* Now arrow_rect contains the inner rect ; we want to correct the width
-     * to what the arrow needs (see gtk_combo_box_size_allocate) */
-    gtk_widget_size_request(gComboBoxArrowWidget, &arrow_req);
-    if (direction == GTK_TEXT_DIR_LTR)
-        arrow_rect.x += arrow_rect.width - arrow_req.width;
-    arrow_rect.width = arrow_req.width;
-
-    calculate_arrow_rect(gComboBoxArrowWidget,
-                         &arrow_rect, &real_arrow_rect, direction);
-
-    style = gComboBoxArrowWidget->style;
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    gtk_widget_size_allocate(gComboBoxWidget, rect);
-
-    gtk_paint_arrow(style, drawable, state_type, shadow_type, cliprect,
-                    gComboBoxArrowWidget, "arrow",  GTK_ARROW_DOWN, TRUE,
-                    real_arrow_rect.x, real_arrow_rect.y,
-                    real_arrow_rect.width, real_arrow_rect.height);
-
-
-    /* If there is no separator in the theme, there's nothing left to do. */
-    if (!gComboBoxSeparatorWidget)
-        return MOZ_GTK_SUCCESS;
-
-    style = gComboBoxSeparatorWidget->style;
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    gtk_widget_style_get(gComboBoxSeparatorWidget,
-                         "wide-separators", &wide_separators,
-                         "separator-width", &separator_width,
-                         NULL);
-
-    if (wide_separators) {
-        if (direction == GTK_TEXT_DIR_LTR)
-            arrow_rect.x -= separator_width;
-        else
-            arrow_rect.x += arrow_rect.width;
-
-        gtk_paint_box(style, drawable,
-                      GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_OUT,
-                      cliprect, gComboBoxSeparatorWidget, "vseparator",
-                      arrow_rect.x, arrow_rect.y,
-                      separator_width, arrow_rect.height);
-    } else {
-        if (direction == GTK_TEXT_DIR_LTR)
-            arrow_rect.x -= XTHICKNESS(style);
-        else
-            arrow_rect.x += arrow_rect.width;
-
-        gtk_paint_vline(style, drawable, GTK_STATE_NORMAL, cliprect,
-                        gComboBoxSeparatorWidget, "vseparator",
-                        arrow_rect.y, arrow_rect.y + arrow_rect.height,
-                        arrow_rect.x);
-    }
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_arrow_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                    GdkRectangle* cliprect, GtkWidgetState* state,
-                    GtkArrowType arrow_type, GtkTextDirection direction)
-{
-    GtkStyle* style;
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkShadowType shadow_type = state->active ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
-    GdkRectangle arrow_rect;
-
-    ensure_button_arrow_widget();
-    style = gButtonArrowWidget->style;
-    gtk_widget_set_direction(gButtonArrowWidget, direction);
-
-    calculate_arrow_rect(gButtonArrowWidget, rect, &arrow_rect,
-                         direction);
-
-    if (direction == GTK_TEXT_DIR_RTL) {
-        if (arrow_type == GTK_ARROW_LEFT)
-            arrow_type = GTK_ARROW_RIGHT;
-        else if (arrow_type == GTK_ARROW_RIGHT)
-            arrow_type = GTK_ARROW_LEFT;
-    }
-
-    TSOffsetStyleGCs(style, arrow_rect.x, arrow_rect.y);
-    gtk_paint_arrow(style, drawable, state_type, shadow_type, cliprect,
-                    gButtonArrowWidget, "arrow",  arrow_type, TRUE,
-                    arrow_rect.x, arrow_rect.y, arrow_rect.width, arrow_rect.height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_combo_box_entry_button_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                                     GdkRectangle* cliprect,
-                                     GtkWidgetState* state,
-                                     gboolean input_focus,
-                                     GtkTextDirection direction)
-{
-    gint x_displacement, y_displacement;
-    GdkRectangle arrow_rect, real_arrow_rect;
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkShadowType shadow_type = state->active ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
-    GtkStyle* style;
-
-    ensure_combo_box_entry_widgets();
-
-    if (input_focus) {
-        /* Some themes draw a complementary focus ring for the dropdown button
-         * when the dropdown entry has focus */
-        GTK_WIDGET_SET_FLAGS(gComboBoxEntryTextareaWidget, GTK_HAS_FOCUS);
-    }
-
-    moz_gtk_button_paint(drawable, rect, cliprect, state, GTK_RELIEF_NORMAL,
-                         gComboBoxEntryButtonWidget, direction);
-
-    if (input_focus)
-        GTK_WIDGET_UNSET_FLAGS(gComboBoxEntryTextareaWidget, GTK_HAS_FOCUS);
-
-    calculate_button_inner_rect(gComboBoxEntryButtonWidget,
-                                rect, &arrow_rect, direction, FALSE);
-    if (state_type == GTK_STATE_ACTIVE) {
-        gtk_widget_style_get(gComboBoxEntryButtonWidget,
-                             "child-displacement-x", &x_displacement,
-                             "child-displacement-y", &y_displacement,
-                             NULL);
-        arrow_rect.x += x_displacement;
-        arrow_rect.y += y_displacement;
-    }
-
-    calculate_arrow_rect(gComboBoxEntryArrowWidget,
-                         &arrow_rect, &real_arrow_rect, direction);
-
-    style = gComboBoxEntryArrowWidget->style;
-    TSOffsetStyleGCs(style, real_arrow_rect.x, real_arrow_rect.y);
-
-    gtk_paint_arrow(style, drawable, state_type, shadow_type, cliprect,
-                    gComboBoxEntryArrowWidget, "arrow",  GTK_ARROW_DOWN, TRUE,
-                    real_arrow_rect.x, real_arrow_rect.y,
-                    real_arrow_rect.width, real_arrow_rect.height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_container_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                        GdkRectangle* cliprect, GtkWidgetState* state, 
-                        gboolean isradio, GtkTextDirection direction)
-{
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkStyle* style;
-    GtkWidget *widget;
-    gboolean interior_focus;
-    gint focus_width, focus_pad;
-
-    if (isradio) {
-        ensure_radiobutton_widget();
-        widget = gRadiobuttonWidget;
-    } else {
-        ensure_checkbox_widget();
-        widget = gCheckboxWidget;
-    }
-    gtk_widget_set_direction(widget, direction);
-
-    style = widget->style;
-    moz_gtk_widget_get_focus(widget, &interior_focus, &focus_width,
-                             &focus_pad);
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    /* The detail argument for the gtk_paint_* calls below are "checkbutton"
-       even for radio buttons, to match what gtk does. */
-
-    /* this is for drawing a prelight box */
-    if (state_type == GTK_STATE_PRELIGHT || state_type == GTK_STATE_ACTIVE) {
-        gtk_paint_flat_box(style, drawable, GTK_STATE_PRELIGHT,
-                           GTK_SHADOW_ETCHED_OUT, cliprect, widget,
-                           "checkbutton",
-                           rect->x, rect->y, rect->width, rect->height);
-    }
-
-    if (state_type != GTK_STATE_NORMAL && state_type != GTK_STATE_PRELIGHT)
-        state_type = GTK_STATE_NORMAL;
-
-    if (state->focused && !interior_focus) {
-        gtk_paint_focus(style, drawable, state_type, cliprect, widget,
-                        "checkbutton",
-                        rect->x, rect->y, rect->width, rect->height);
-    }
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_toggle_label_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                           GdkRectangle* cliprect, GtkWidgetState* state, 
-                           gboolean isradio, GtkTextDirection direction)
-{
-    GtkStateType state_type;
-    GtkStyle *style;
-    GtkWidget *widget;
-    gboolean interior_focus;
-
-    if (!state->focused)
-        return MOZ_GTK_SUCCESS;
-
-    if (isradio) {
-        ensure_radiobutton_widget();
-        widget = gRadiobuttonWidget;
-    } else {
-        ensure_checkbox_widget();
-        widget = gCheckboxWidget;
-    }
-    gtk_widget_set_direction(widget, direction);
-
-    gtk_widget_style_get(widget, "interior-focus", &interior_focus, NULL);
-    if (!interior_focus)
-        return MOZ_GTK_SUCCESS;
-
-    state_type = ConvertGtkState(state);
-
-    style = widget->style;
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    /* Always "checkbutton" to match gtkcheckbutton.c */
-    gtk_paint_focus(style, drawable, state_type, cliprect, widget,
-                    "checkbutton",
-                    rect->x, rect->y, rect->width, rect->height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_toolbar_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                      GdkRectangle* cliprect, GtkTextDirection direction)
-{
-    GtkStyle* style;
-    GtkShadowType shadow_type;
-
-    ensure_toolbar_widget();
-    gtk_widget_set_direction(gToolbarWidget, direction);
-
-    style = gToolbarWidget->style;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    gtk_style_apply_default_background(style, drawable, TRUE,
-                                       GTK_STATE_NORMAL,
-                                       cliprect, rect->x, rect->y,
-                                       rect->width, rect->height);
-
-    gtk_widget_style_get(gToolbarWidget, "shadow-type", &shadow_type, NULL);
-
-    gtk_paint_box (style, drawable, GTK_STATE_NORMAL, shadow_type,
-                   cliprect, gToolbarWidget, "toolbar",
-                   rect->x, rect->y, rect->width, rect->height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_toolbar_separator_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                                GdkRectangle* cliprect,
-                                GtkTextDirection direction)
-{
-    GtkStyle* style;
-    gint     separator_width;
-    gint     paint_width;
-    gboolean wide_separators;
-    
-    /* Defined as constants in GTK+ 2.10.14 */
-    const double start_fraction = 0.2;
-    const double end_fraction = 0.8;
-
-    ensure_toolbar_separator_widget();
-    gtk_widget_set_direction(gToolbarSeparatorWidget, direction);
-
-    style = gToolbarSeparatorWidget->style;
-
-    gtk_widget_style_get(gToolbarWidget,
-                         "wide-separators", &wide_separators,
-                         "separator-width", &separator_width,
-                         NULL);
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    if (wide_separators) {
-        if (separator_width > rect->width)
-            separator_width = rect->width;
-
-        gtk_paint_box(style, drawable,
-                      GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_OUT,
-                      cliprect, gToolbarWidget, "vseparator",
-                      rect->x + (rect->width - separator_width) / 2,
-                      rect->y + rect->height * start_fraction,
-                      separator_width,
-                      rect->height * (end_fraction - start_fraction));
-                       
-    } else {
-        paint_width = style->xthickness;
-        
-        if (paint_width > rect->width)
-            paint_width = rect->width;
-    
-        gtk_paint_vline(style, drawable,
-                        GTK_STATE_NORMAL, cliprect, gToolbarSeparatorWidget,
-                        "toolbar",
-                        rect->y + rect->height * start_fraction,
-                        rect->y + rect->height * end_fraction,
-                        rect->x + (rect->width - paint_width) / 2);
-    }
-    
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_tooltip_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                      GdkRectangle* cliprect, GtkTextDirection direction)
-{
-    GtkStyle* style;
-
-    ensure_tooltip_widget();
-    gtk_widget_set_direction(gTooltipWidget, direction);
-
-    style = gtk_rc_get_style_by_paths(gtk_settings_get_default(),
-                                      "gtk-tooltips", "GtkWindow",
-                                      GTK_TYPE_WINDOW);
-
-    style = gtk_style_attach(style, gTooltipWidget->window);
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_paint_flat_box(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
-                       cliprect, gTooltipWidget, "tooltip",
-                       rect->x, rect->y, rect->width, rect->height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_resizer_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                      GdkRectangle* cliprect, GtkWidgetState* state,
-                      GtkTextDirection direction)
-{
-    GtkStyle* style;
-    GtkStateType state_type = ConvertGtkState(state);
-
-    ensure_frame_widget();
-    gtk_widget_set_direction(gStatusbarWidget, direction);
-
-    style = gStatusbarWidget->style;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    gtk_paint_resize_grip(style, drawable, state_type, cliprect, gStatusbarWidget,
-                          "statusbar", (direction == GTK_TEXT_DIR_LTR) ?
-                          GDK_WINDOW_EDGE_SOUTH_EAST :
-                          GDK_WINDOW_EDGE_SOUTH_WEST,
-                          rect->x, rect->y, rect->width, rect->height);
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_frame_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                    GdkRectangle* cliprect, GtkTextDirection direction)
-{
-    GtkStyle* style;
-    GtkShadowType shadow_type;
-
-    ensure_frame_widget();
-    gtk_widget_set_direction(gFrameWidget, direction);
-
-    style = gFrameWidget->style;
-
-    gtk_widget_style_get(gStatusbarWidget, "shadow-type", &shadow_type, NULL);
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_paint_shadow(style, drawable, GTK_STATE_NORMAL, shadow_type,
-                     cliprect, gFrameWidget, "frame", rect->x, rect->y,
-                     rect->width, rect->height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_progressbar_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                          GdkRectangle* cliprect, GtkTextDirection direction)
-{
-    GtkStyle* style;
-
-    ensure_progress_widget();
-    gtk_widget_set_direction(gProgressWidget, direction);
-
-    style = gProgressWidget->style;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_paint_box(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_IN,
-                  cliprect, gProgressWidget, "trough", rect->x, rect->y,
-                  rect->width, rect->height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_progress_chunk_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                             GdkRectangle* cliprect, GtkTextDirection direction,
-                             WidgetNodeType widget)
-{
-    GtkStyle* style;
-
-    ensure_progress_widget();
-    gtk_widget_set_direction(gProgressWidget, direction);
-
-    style = gProgressWidget->style;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    if (widget == MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE ||
-        widget == MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE) {
-      /**
-       * The bar's size and the bar speed are set depending of the progress'
-       * size. These could also be constant for all progress bars easily.
-       */
-      gboolean vertical = (widget == MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE);
-
-      /* The size of the dimension we are going to use for the animation. */
-      const gint progressSize = vertical ? rect->height : rect->width;
-
-      /* The bar is using a fifth of the element size, based on GtkProgressBar
-       * activity-blocks property. */
-      const gint barSize = MAX(1, progressSize / 5);
-
-      /* Represents the travel that has to be done for a complete cycle. */
-      const gint travel = 2 * (progressSize - barSize);
-
-      /* period equals to travel / pixelsPerMillisecond
-       * where pixelsPerMillisecond equals progressSize / 1000.0.
-       * This is equivalent to 1600. */
-      static const guint period = 1600;
-      const gint t = PR_IntervalToMilliseconds(PR_IntervalNow()) % period;
-      const gint dx = travel * t / period;
-
-      if (vertical) {
-        rect->y += (dx < travel / 2) ? dx : travel - dx;
-        rect->height = barSize;
-      } else {
-        rect->x += (dx < travel / 2) ? dx : travel - dx;
-        rect->width = barSize;
-      }
-    }
-
-    gtk_paint_box(style, drawable, GTK_STATE_PRELIGHT, GTK_SHADOW_OUT,
-                  cliprect, gProgressWidget, "bar", rect->x, rect->y,
-                  rect->width, rect->height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_get_tab_thickness(WidgetNodeType aNodeType)
-{
-    ensure_tab_widget();
-    if (YTHICKNESS(gTabWidget->style) < 2)
-        return 2; /* some themes don't set ythickness correctly */
-
-    return YTHICKNESS(gTabWidget->style);
-}
-
-static gint
-moz_gtk_tab_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                  GdkRectangle* cliprect, GtkWidgetState* state,
-                  GtkTabFlags flags, GtkTextDirection direction,
-                  WidgetNodeType widget)
-{
-    /* When the tab isn't selected, we just draw a notebook extension.
-     * When it is selected, we overwrite the adjacent border of the tabpanel
-     * touching the tab with a pierced border (called "the gap") to make the
-     * tab appear physically attached to the tabpanel; see details below. */
-
-    GtkStyle* style;
-    GdkRectangle focusRect;
-    gboolean isBottomTab = (widget == MOZ_GTK_TAB_BOTTOM);
-
-    ensure_tab_widget();
-    gtk_widget_set_direction(gTabWidget, direction);
-
-    style = gTabWidget->style;
-    focusRect = *rect;
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    if ((flags & MOZ_GTK_TAB_SELECTED) == 0) {
-        /* Only draw the tab */
-        gtk_paint_extension(style, drawable, GTK_STATE_ACTIVE, GTK_SHADOW_OUT,
-                            cliprect, gTabWidget, "tab",
-                            rect->x, rect->y, rect->width, rect->height,
-                            isBottomTab ? GTK_POS_TOP : GTK_POS_BOTTOM );
-    } else {
-        /* Draw the tab and the gap
-         * We want the gap to be positioned exactly on the tabpanel top
-         * border; since tabbox.css may set a negative margin so that the tab
-         * frame rect already overlaps the tabpanel frame rect, we need to take
-         * that into account when drawing. To that effect, nsNativeThemeGTK
-         * passes us this negative margin (bmargin in the graphic below) in the
-         * lowest bits of |flags|.  We use it to set gap_voffset, the distance
-         * between the top of the gap and the bottom of the tab (resp. the
-         * bottom of the gap and the top of the tab when we draw a bottom tab),
-         * while ensuring that the gap always touches the border of the tab,
-         * i.e. 0 <= gap_voffset <= gap_height, to avoid surprinsing results
-         * with big negative or positive margins.
-         * Here is a graphical explanation in the case of top tabs:
-         *             ___________________________
-         *            /                           \
-         *           |            T A B            |
-         * ----------|. . . . . . . . . . . . . . .|----- top of tabpanel
-         *           :    ^       bmargin          :  ^
-         *           :    | (-negative margin,     :  |
-         *  bottom   :    v  passed in flags)      :  |       gap_height
-         *    of  -> :.............................:  |    (the size of the
-         * the tab   .       part of the gap       .  |  tabpanel top border)
-         *           .      outside of the tab     .  v
-         * ----------------------------------------------
-         *
-         * To draw the gap, we use gtk_paint_box_gap(), see comment in
-         * moz_gtk_tabpanels_paint(). This box_gap is made 3 * gap_height tall,
-         * which should suffice to ensure that the only visible border is the
-         * pierced one.  If the tab is in the middle, we make the box_gap begin
-         * a bit to the left of the tab and end a bit to the right, adjusting
-         * the gap position so it still is under the tab, because we want the
-         * rendering of a gap in the middle of a tabpanel.  This is the role of
-         * the gints gap_{l,r}_offset. On the contrary, if the tab is the
-         * first, we align the start border of the box_gap with the start
-         * border of the tab (left if LTR, right if RTL), by setting the
-         * appropriate offset to 0.*/
-        gint gap_loffset, gap_roffset, gap_voffset, gap_height;
-
-        /* Get height needed by the gap */
-        gap_height = moz_gtk_get_tab_thickness(widget);
-
-        /* Extract gap_voffset from the first bits of flags */
-        gap_voffset = flags & MOZ_GTK_TAB_MARGIN_MASK;
-        if (gap_voffset > gap_height)
-            gap_voffset = gap_height;
-
-        /* Set gap_{l,r}_offset to appropriate values */
-        gap_loffset = gap_roffset = 20; /* should be enough */
-        if (flags & MOZ_GTK_TAB_FIRST) {
-            if (direction == GTK_TEXT_DIR_RTL)
-                gap_roffset = 0;
-            else
-                gap_loffset = 0;
-        }
-
-        if (isBottomTab) {
-            /* Draw the tab */
-            focusRect.y += gap_voffset;
-            focusRect.height -= gap_voffset;
-            gtk_paint_extension(style, drawable, GTK_STATE_NORMAL,
-                                GTK_SHADOW_OUT, cliprect, gTabWidget, "tab",
-                                rect->x, rect->y + gap_voffset, rect->width,
-                                rect->height - gap_voffset, GTK_POS_TOP);
-
-            /* Draw the gap; erase with background color before painting in
-             * case theme does not */
-            gtk_style_apply_default_background(style, drawable, TRUE,
-                                               GTK_STATE_NORMAL, cliprect,
-                                               rect->x,
-                                               rect->y + gap_voffset
-                                                       - gap_height,
-                                               rect->width, gap_height);
-            gtk_paint_box_gap(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
-                              cliprect, gTabWidget, "notebook",
-                              rect->x - gap_loffset,
-                              rect->y + gap_voffset - 3 * gap_height,
-                              rect->width + gap_loffset + gap_roffset,
-                              3 * gap_height, GTK_POS_BOTTOM,
-                              gap_loffset, rect->width);
-        } else {
-            /* Draw the tab */
-            focusRect.height -= gap_voffset;
-            gtk_paint_extension(style, drawable, GTK_STATE_NORMAL,
-                                GTK_SHADOW_OUT, cliprect, gTabWidget, "tab",
-                                rect->x, rect->y, rect->width,
-                                rect->height - gap_voffset, GTK_POS_BOTTOM);
-
-            /* Draw the gap; erase with background color before painting in
-             * case theme does not */
-            gtk_style_apply_default_background(style, drawable, TRUE,
-                                               GTK_STATE_NORMAL, cliprect,
-                                               rect->x,
-                                               rect->y + rect->height
-                                                       - gap_voffset,
-                                               rect->width, gap_height);
-            gtk_paint_box_gap(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
-                              cliprect, gTabWidget, "notebook",
-                              rect->x - gap_loffset,
-                              rect->y + rect->height - gap_voffset,
-                              rect->width + gap_loffset + gap_roffset,
-                              3 * gap_height, GTK_POS_TOP,
-                              gap_loffset, rect->width);
-        }
-
-    }
-
-    if (state->focused) {
-      /* Paint the focus ring */
-      focusRect.x += XTHICKNESS(style);
-      focusRect.width -= XTHICKNESS(style) * 2;
-      focusRect.y += YTHICKNESS(style);
-      focusRect.height -= YTHICKNESS(style) * 2;
-
-      gtk_paint_focus(style, drawable,
-                      /* Believe it or not, NORMAL means a selected tab and
-                         ACTIVE means an unselected tab. */
-                      (flags & MOZ_GTK_TAB_SELECTED) ? GTK_STATE_NORMAL
-                                                     : GTK_STATE_ACTIVE,
-                      cliprect, gTabWidget, "tab",
-                      focusRect.x, focusRect.y, focusRect.width, focusRect.height);
-    }
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_tabpanels_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                        GdkRectangle* cliprect, GtkTextDirection direction)
-{
-    /* We have three problems here:
-     * - Most engines draw gtk_paint_box differently to gtk_paint_box_gap, the
-     *   former implies there are no tabs, eg. Clearlooks.
-     * - Wanting a gap of width 0 doesn't actually guarantee a zero-width gap, eg.
-     *   Clearlooks.
-     * - Our old approach of a negative X position could cause rendering errors
-     *   on the box's corner, eg. themes using the Pixbuf engine.
-     */
-    GtkStyle* style;
-    GdkRectangle halfClipRect;
-
-    ensure_tab_widget();
-    gtk_widget_set_direction(gTabWidget, direction);
-
-    style = gTabWidget->style;
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    /* Our approach is as follows:
-     * - Draw the box in two passes. Pass in a clip rect to draw the left half of the
-     *   box, with the gap specified to the right outside the clip rect so that it is
-     *   not drawn.
-     * - The right half is drawn with the gap to the left outside the modified clip rect.
-     */
-    if (!gdk_rectangle_intersect(rect, cliprect, &halfClipRect))
-      return MOZ_GTK_SUCCESS;
-
-    halfClipRect.width = (halfClipRect.width / 2) + 1;
-    gtk_paint_box_gap(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
-                      &halfClipRect, gTabWidget, "notebook", rect->x, rect->y,
-                      rect->width, rect->height,
-                      GTK_POS_TOP, halfClipRect.width + 1, 0);
-
-    halfClipRect.x += halfClipRect.width;
-    gtk_paint_box_gap(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
-                      &halfClipRect, gTabWidget, "notebook", rect->x, rect->y,
-                      rect->width, rect->height,
-                      GTK_POS_TOP, -10, 0);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_tab_scroll_arrow_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                               GdkRectangle* cliprect, GtkWidgetState* state,
-                               GtkArrowType arrow_type,
-                               GtkTextDirection direction)
-{
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkShadowType shadow_type = state->active ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
-    GtkStyle* style;
-    gint arrow_size = MIN(rect->width, rect->height);
-    gint x = rect->x + (rect->width - arrow_size) / 2;
-    gint y = rect->y + (rect->height - arrow_size) / 2;
-
-    ensure_tab_widget();
-
-    style = gTabWidget->style;
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    if (direction == GTK_TEXT_DIR_RTL) {
-        arrow_type = (arrow_type == GTK_ARROW_LEFT) ?
-                         GTK_ARROW_RIGHT : GTK_ARROW_LEFT;
-    }
-
-    gtk_paint_arrow(style, drawable, state_type, shadow_type, NULL,
-                    gTabWidget, "notebook", arrow_type, TRUE,
-                    x, y, arrow_size, arrow_size);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_menu_bar_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                       GdkRectangle* cliprect, GtkTextDirection direction)
-{
-    GtkStyle* style;
-    GtkShadowType shadow_type;
-    ensure_menu_bar_widget();
-    gtk_widget_set_direction(gMenuBarWidget, direction);
-
-    gtk_widget_style_get(gMenuBarWidget, "shadow-type", &shadow_type, NULL);
-
-    style = gMenuBarWidget->style;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_style_apply_default_background(style, drawable, TRUE, GTK_STATE_NORMAL,
-                                       cliprect, rect->x, rect->y,
-                                       rect->width, rect->height);
-
-    gtk_paint_box(style, drawable, GTK_STATE_NORMAL, shadow_type,
-                  cliprect, gMenuBarWidget, "menubar", rect->x, rect->y,
-                  rect->width, rect->height);
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_menu_popup_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                         GdkRectangle* cliprect, GtkTextDirection direction)
-{
-    GtkStyle* style;
-    ensure_menu_popup_widget();
-    gtk_widget_set_direction(gMenuPopupWidget, direction);
-
-    style = gMenuPopupWidget->style;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_style_apply_default_background(style, drawable, TRUE, GTK_STATE_NORMAL,
-                                       cliprect, rect->x, rect->y,
-                                       rect->width, rect->height);
-    gtk_paint_box(style, drawable, GTK_STATE_NORMAL, GTK_SHADOW_OUT, 
-                  cliprect, gMenuPopupWidget, "menu",
-                  rect->x, rect->y, rect->width, rect->height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_menu_separator_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                             GdkRectangle* cliprect, GtkTextDirection direction)
-{
-    GtkStyle* style;
-    gboolean wide_separators;
-    gint separator_height;
-    guint horizontal_padding;
-    gint paint_height;
-
-    ensure_menu_separator_widget();
-    gtk_widget_set_direction(gMenuSeparatorWidget, direction);
-
-    style = gMenuSeparatorWidget->style;
-
-    gtk_widget_style_get(gMenuSeparatorWidget,
-                         "wide-separators",    &wide_separators,
-                         "separator-height",   &separator_height,
-                         "horizontal-padding", &horizontal_padding,
-                         NULL);
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-
-    if (wide_separators) {
-        if (separator_height > rect->height)
-            separator_height = rect->height;
-
-        gtk_paint_box(style, drawable,
-                      GTK_STATE_NORMAL, GTK_SHADOW_ETCHED_OUT,
-                      cliprect, gMenuSeparatorWidget, "hseparator",
-                      rect->x + horizontal_padding + style->xthickness,
-                      rect->y + (rect->height - separator_height - style->ythickness) / 2,
-                      rect->width - 2 * (horizontal_padding + style->xthickness),
-                      separator_height);
-    } else {
-        paint_height = style->ythickness;
-        if (paint_height > rect->height)
-            paint_height = rect->height;
-
-        gtk_paint_hline(style, drawable,
-                        GTK_STATE_NORMAL, cliprect, gMenuSeparatorWidget,
-                        "menuitem",
-                        rect->x + horizontal_padding + style->xthickness,
-                        rect->x + rect->width - horizontal_padding - style->xthickness - 1,
-                        rect->y + (rect->height - style->ythickness) / 2);
-    }
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_menu_item_paint(WidgetNodeType widget, GdkDrawable* drawable,
-                        GdkRectangle* rect, GdkRectangle* cliprect,
-                        GtkWidgetState* state, GtkTextDirection direction)
-{
-    GtkStyle* style;
-    GtkShadowType shadow_type;
-    GtkWidget* item_widget;
-
-    if (state->inHover && !state->disabled) {
-        if (widget == MOZ_GTK_MENUBARITEM) {
-            ensure_menu_bar_item_widget();
-            item_widget = gMenuBarItemWidget;
-        } else {
-            ensure_menu_item_widget();
-            item_widget = gMenuItemWidget;
-        }
-        gtk_widget_set_direction(item_widget, direction);
-        
-        style = item_widget->style;
-        TSOffsetStyleGCs(style, rect->x, rect->y);
-
-        gtk_widget_style_get(item_widget, "selected-shadow-type",
-                             &shadow_type, NULL);
-
-        gtk_paint_box(style, drawable, GTK_STATE_PRELIGHT, shadow_type,
-                      cliprect, item_widget, "menuitem", rect->x, rect->y,
-                      rect->width, rect->height);
-    }
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_menu_arrow_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                         GdkRectangle* cliprect, GtkWidgetState* state,
-                         GtkTextDirection direction)
-{
-    GtkStyle* style;
-    GtkStateType state_type = ConvertGtkState(state);
-
-    ensure_menu_item_widget();
-    gtk_widget_set_direction(gMenuItemWidget, direction);
-
-    style = gMenuItemWidget->style;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_paint_arrow(style, drawable, state_type,
-                    (state_type == GTK_STATE_PRELIGHT) ? GTK_SHADOW_IN : GTK_SHADOW_OUT,
-                    cliprect, gMenuItemWidget, "menuitem",
-                    (direction == GTK_TEXT_DIR_LTR) ? GTK_ARROW_RIGHT : GTK_ARROW_LEFT,
-                    TRUE, rect->x, rect->y, rect->width, rect->height);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_check_menu_item_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                              GdkRectangle* cliprect, GtkWidgetState* state,
-                              gboolean checked, gboolean isradio,
-                              GtkTextDirection direction)
-{
-    GtkStateType state_type = ConvertGtkState(state);
-    GtkStyle* style;
-    GtkShadowType shadow_type = (checked)?GTK_SHADOW_IN:GTK_SHADOW_OUT;
-    gint offset;
-    gint indicator_size, horizontal_padding;
-    gint x, y;
-
-    moz_gtk_menu_item_paint(MOZ_GTK_MENUITEM, drawable, rect, cliprect, state,
-                            direction);
-
-    ensure_check_menu_item_widget();
-    gtk_widget_set_direction(gCheckMenuItemWidget, direction);
-
-    gtk_widget_style_get (gCheckMenuItemWidget,
-                          "indicator-size", &indicator_size,
-                          "horizontal-padding", &horizontal_padding,
-                          NULL);
-
-    if (checked || GTK_CHECK_MENU_ITEM(gCheckMenuItemWidget)->always_show_toggle) {
-      style = gCheckMenuItemWidget->style;
-
-      offset = GTK_CONTAINER(gCheckMenuItemWidget)->border_width +
-             gCheckMenuItemWidget->style->xthickness + 2;
-
-      x = (direction == GTK_TEXT_DIR_RTL) ?
-            rect->width - indicator_size - offset - horizontal_padding: rect->x + offset + horizontal_padding;
-      y = rect->y + (rect->height - indicator_size) / 2;
-
-      TSOffsetStyleGCs(style, x, y);
-      gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gCheckMenuItemWidget),
-                                     checked);
-
-      if (isradio) {
-        gtk_paint_option(style, drawable, state_type, shadow_type, cliprect,
-                         gCheckMenuItemWidget, "option",
-                         x, y, indicator_size, indicator_size);
-      } else {
-        gtk_paint_check(style, drawable, state_type, shadow_type, cliprect,
-                        gCheckMenuItemWidget, "check",
-                        x, y, indicator_size, indicator_size);
-      }
-    }
-
-    return MOZ_GTK_SUCCESS;
-}
-
-static gint
-moz_gtk_window_paint(GdkDrawable* drawable, GdkRectangle* rect,
-                     GdkRectangle* cliprect, GtkTextDirection direction)
-{
-    GtkStyle* style;
-
-    ensure_window_widget();
-    gtk_widget_set_direction(gProtoWindow, direction);
-
-    style = gProtoWindow->style;
-
-    TSOffsetStyleGCs(style, rect->x, rect->y);
-    gtk_style_apply_default_background(style, drawable, TRUE,
-                                       GTK_STATE_NORMAL,
-                                       cliprect, rect->x, rect->y,
-                                       rect->width, rect->height);
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_get_widget_border(WidgetNodeType widget, gint* left, gint* top,
-                          gint* right, gint* bottom, GtkTextDirection direction,
-                          gboolean inhtml)
-{
-    GtkWidget* w;
-
-    switch (widget) {
-    case MOZ_GTK_BUTTON:
-    case MOZ_GTK_TOOLBAR_BUTTON:
-        {
-            GtkBorder inner_border;
-            gboolean interior_focus;
-            gint focus_width, focus_pad;
-
-            ensure_button_widget();
-            *left = *top = *right = *bottom = GTK_CONTAINER(gButtonWidget)->border_width;
-
-            /* Don't add this padding in HTML, otherwise the buttons will
-               become too big and stuff the layout. */
-            if (!inhtml) {
-                moz_gtk_widget_get_focus(gButtonWidget, &interior_focus, &focus_width, &focus_pad);
-                moz_gtk_button_get_inner_border(gButtonWidget, &inner_border);
-                *left += focus_width + focus_pad + inner_border.left;
-                *right += focus_width + focus_pad + inner_border.right;
-                *top += focus_width + focus_pad + inner_border.top;
-                *bottom += focus_width + focus_pad + inner_border.bottom;
-            }
-
-            *left += gButtonWidget->style->xthickness;
-            *right += gButtonWidget->style->xthickness;
-            *top += gButtonWidget->style->ythickness;
-            *bottom += gButtonWidget->style->ythickness;
-            return MOZ_GTK_SUCCESS;
-        }
-    case MOZ_GTK_ENTRY:
-        ensure_entry_widget();
-        w = gEntryWidget;
-        break;
-    case MOZ_GTK_TREEVIEW:
-        ensure_tree_view_widget();
-        w = gTreeViewWidget;
-        break;
-    case MOZ_GTK_TREE_HEADER_CELL:
-        {
-            /* A Tree Header in GTK is just a different styled button 
-             * It must be placed in a TreeView for getting the correct style
-             * assigned.
-             * That is why the following code is the same as for MOZ_GTK_BUTTON.  
-             * */
-
-            GtkBorder inner_border;
-            gboolean interior_focus;
-            gint focus_width, focus_pad;
-
-            ensure_tree_header_cell_widget();
-            *left = *top = *right = *bottom = GTK_CONTAINER(gTreeHeaderCellWidget)->border_width;
-
-            moz_gtk_widget_get_focus(gTreeHeaderCellWidget, &interior_focus, &focus_width, &focus_pad);
-            moz_gtk_button_get_inner_border(gTreeHeaderCellWidget, &inner_border);
-            *left += focus_width + focus_pad + inner_border.left;
-            *right += focus_width + focus_pad + inner_border.right;
-            *top += focus_width + focus_pad + inner_border.top;
-            *bottom += focus_width + focus_pad + inner_border.bottom;
-            
-            *left += gTreeHeaderCellWidget->style->xthickness;
-            *right += gTreeHeaderCellWidget->style->xthickness;
-            *top += gTreeHeaderCellWidget->style->ythickness;
-            *bottom += gTreeHeaderCellWidget->style->ythickness;
-            return MOZ_GTK_SUCCESS;
-        }
-    case MOZ_GTK_TREE_HEADER_SORTARROW:
-        ensure_tree_header_cell_widget();
-        w = gTreeHeaderSortArrowWidget;
-        break;
-    case MOZ_GTK_DROPDOWN_ENTRY:
-        ensure_combo_box_entry_widgets();
-        w = gComboBoxEntryTextareaWidget;
-        break;
-    case MOZ_GTK_DROPDOWN_ARROW:
-        ensure_combo_box_entry_widgets();
-        w = gComboBoxEntryButtonWidget;
-        break;
-    case MOZ_GTK_DROPDOWN:
-        {
-            /* We need to account for the arrow on the dropdown, so text
-             * doesn't come too close to the arrow, or in some cases spill
-             * into the arrow. */
-            gboolean ignored_interior_focus, wide_separators;
-            gint focus_width, focus_pad, separator_width;
-            GtkRequisition arrow_req;
-
-            ensure_combo_box_widgets();
-
-            *left = GTK_CONTAINER(gComboBoxButtonWidget)->border_width;
-
-            if (!inhtml) {
-                moz_gtk_widget_get_focus(gComboBoxButtonWidget,
-                                         &ignored_interior_focus,
-                                         &focus_width, &focus_pad);
-                *left += focus_width + focus_pad;
-            }
-
-            *top = *left + gComboBoxButtonWidget->style->ythickness;
-            *left += gComboBoxButtonWidget->style->xthickness;
-
-            *right = *left; *bottom = *top;
-
-            /* If there is no separator, don't try to count its width. */
-            separator_width = 0;
-            if (gComboBoxSeparatorWidget) {
-                gtk_widget_style_get(gComboBoxSeparatorWidget,
-                                     "wide-separators", &wide_separators,
-                                     "separator-width", &separator_width,
-                                     NULL);
-
-                if (!wide_separators)
-                    separator_width =
-                        XTHICKNESS(gComboBoxSeparatorWidget->style);
-            }
-
-            gtk_widget_size_request(gComboBoxArrowWidget, &arrow_req);
-
-            if (direction == GTK_TEXT_DIR_RTL)
-                *left += separator_width + arrow_req.width;
-            else
-                *right += separator_width + arrow_req.width;
-
-            return MOZ_GTK_SUCCESS;
-        }
-    case MOZ_GTK_TABPANELS:
-        ensure_tab_widget();
-        w = gTabWidget;
-        break;
-    case MOZ_GTK_PROGRESSBAR:
-        ensure_progress_widget();
-        w = gProgressWidget;
-        break;
-    case MOZ_GTK_SPINBUTTON_ENTRY:
-    case MOZ_GTK_SPINBUTTON_UP:
-    case MOZ_GTK_SPINBUTTON_DOWN:
-        ensure_spin_widget();
-        w = gSpinWidget;
-        break;
-    case MOZ_GTK_SCALE_HORIZONTAL:
-        ensure_scale_widget();
-        w = gHScaleWidget;
-        break;
-    case MOZ_GTK_SCALE_VERTICAL:
-        ensure_scale_widget();
-        w = gVScaleWidget;
-        break;
-    case MOZ_GTK_FRAME:
-        ensure_frame_widget();
-        w = gFrameWidget;
-        break;
-    case MOZ_GTK_CHECKBUTTON_LABEL:
-    case MOZ_GTK_RADIOBUTTON_LABEL:
-        {
-            gboolean interior_focus;
-            gint focus_width, focus_pad;
-
-            /* If the focus is interior, then the label has a border of
-               (focus_width + focus_pad). */
-            if (widget == MOZ_GTK_CHECKBUTTON_LABEL) {
-                ensure_checkbox_widget();
-                moz_gtk_widget_get_focus(gCheckboxWidget, &interior_focus,
-                                           &focus_width, &focus_pad);
-            }
-            else {
-                ensure_radiobutton_widget();
-                moz_gtk_widget_get_focus(gRadiobuttonWidget, &interior_focus,
-                                        &focus_width, &focus_pad);
-            }
-
-            if (interior_focus)
-                *left = *top = *right = *bottom = (focus_width + focus_pad);
-            else
-                *left = *top = *right = *bottom = 0;
-
-            return MOZ_GTK_SUCCESS;
-        }
-
-    case MOZ_GTK_CHECKBUTTON_CONTAINER:
-    case MOZ_GTK_RADIOBUTTON_CONTAINER:
-        {
-            gboolean interior_focus;
-            gint focus_width, focus_pad;
-
-            /* If the focus is _not_ interior, then the container has a border
-               of (focus_width + focus_pad). */
-            if (widget == MOZ_GTK_CHECKBUTTON_CONTAINER) {
-                ensure_checkbox_widget();
-                moz_gtk_widget_get_focus(gCheckboxWidget, &interior_focus,
-                                           &focus_width, &focus_pad);
-                w = gCheckboxWidget;
-            } else {
-                ensure_radiobutton_widget();
-                moz_gtk_widget_get_focus(gRadiobuttonWidget, &interior_focus,
-                                        &focus_width, &focus_pad);
-                w = gRadiobuttonWidget;
-            }
-
-            *left = *top = *right = *bottom = GTK_CONTAINER(w)->border_width;
-
-            if (!interior_focus) {
-                *left += (focus_width + focus_pad);
-                *right += (focus_width + focus_pad);
-                *top += (focus_width + focus_pad);
-                *bottom += (focus_width + focus_pad);
-            }
-
-            return MOZ_GTK_SUCCESS;
-        }
-    case MOZ_GTK_MENUPOPUP:
-        ensure_menu_popup_widget();
-        w = gMenuPopupWidget;
-        break;
-    case MOZ_GTK_MENUBARITEM:
-        // Bug 1274143 for MOZ_GTK_MENUBARITEM.
-        // Fall through to MOZ_GTK_MENUITEM for now.
-    case MOZ_GTK_MENUITEM:
-        ensure_menu_item_widget();
-        ensure_menu_bar_item_widget();
-        w = gMenuItemWidget;
-        break;
-    case MOZ_GTK_CHECKMENUITEM:
-    case MOZ_GTK_RADIOMENUITEM:
-        ensure_check_menu_item_widget();
-        w = gCheckMenuItemWidget;
-        break;
-    case MOZ_GTK_TAB_TOP:
-    case MOZ_GTK_TAB_BOTTOM:
-        ensure_tab_widget();
-        w = gTabWidget;
-        break;
-    case MOZ_GTK_TOOLTIP:
-        // In GTK 2 the spacing between box is set to 4.
-        *left = *top = *right = *bottom = 4;
-        return MOZ_GTK_SUCCESS;
-    /* These widgets have no borders, since they are not containers. */
-    case MOZ_GTK_SPLITTER_HORIZONTAL:
-    case MOZ_GTK_SPLITTER_VERTICAL:
-    case MOZ_GTK_CHECKBUTTON:
-    case MOZ_GTK_RADIOBUTTON:
-    case MOZ_GTK_SCROLLBAR_BUTTON:
-    case MOZ_GTK_SCROLLBAR_HORIZONTAL:
-    case MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL:
-    case MOZ_GTK_SCROLLBAR_VERTICAL:
-    case MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL:
-    case MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL:
-    case MOZ_GTK_SCROLLBAR_THUMB_VERTICAL:
-    case MOZ_GTK_SCALE_THUMB_HORIZONTAL:
-    case MOZ_GTK_SCALE_THUMB_VERTICAL:
-    case MOZ_GTK_GRIPPER:
-    case MOZ_GTK_PROGRESS_CHUNK:
-    case MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE:
-    case MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE:
-    case MOZ_GTK_TREEVIEW_EXPANDER:
-    case MOZ_GTK_TOOLBAR_SEPARATOR:
-    case MOZ_GTK_MENUSEPARATOR:
-    /* These widgets have no borders.*/
-    case MOZ_GTK_INNER_SPIN_BUTTON:
-    case MOZ_GTK_SPINBUTTON:
-    case MOZ_GTK_WINDOW:
-    case MOZ_GTK_RESIZER:
-    case MOZ_GTK_MENUARROW:
-    case MOZ_GTK_TOOLBARBUTTON_ARROW:
-    case MOZ_GTK_TOOLBAR:
-    case MOZ_GTK_MENUBAR:
-    case MOZ_GTK_TAB_SCROLLARROW:
-        *left = *top = *right = *bottom = 0;
-        return MOZ_GTK_SUCCESS;
-    default:
-        g_warning("Unsupported widget type: %d", widget);
-        return MOZ_GTK_UNKNOWN_WIDGET;
-    }
-
-    *right = *left = XTHICKNESS(w->style);
-    *bottom = *top = YTHICKNESS(w->style);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_get_tab_border(gint* left, gint* top, gint* right, gint* bottom, 
-                       GtkTextDirection direction, GtkTabFlags flags,
-                       WidgetNodeType widget)
-{
-    moz_gtk_get_widget_border(widget, left, top,
-                              right, bottom, direction,
-                              FALSE);
-
-    // Top tabs have no bottom border, bottom tabs have no top border
-    if (widget == MOZ_GTK_TAB_BOTTOM) {
-      *top = 0;
-    } else {
-      *bottom = 0;
-    }
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_get_combo_box_entry_button_size(gint* width, gint* height)
-{
-    /*
-     * We get the requisition of the drop down button, which includes
-     * all padding, border and focus line widths the button uses,
-     * as well as the minimum arrow size and its padding
-     * */
-    GtkRequisition requisition;
-    ensure_combo_box_entry_widgets();
-
-    gtk_widget_size_request(gComboBoxEntryButtonWidget, &requisition);
-    *width = requisition.width;
-    *height = requisition.height;
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_get_tab_scroll_arrow_size(gint* width, gint* height)
-{
-    gint arrow_size;
-
-    ensure_tab_widget();
-    gtk_widget_style_get(gTabWidget,
-                         "scroll-arrow-hlength", &arrow_size,
-                         NULL);
-
-    *height = *width = arrow_size;
-
-    return MOZ_GTK_SUCCESS;
-}
-
-void
-moz_gtk_get_arrow_size(WidgetNodeType widgetType, gint* width, gint* height)
-{
-    GtkWidget* widget;
-    switch (widgetType) {
-        case MOZ_GTK_DROPDOWN:
-            ensure_combo_box_widgets();
-            widget = gComboBoxArrowWidget;
-            break;
-        default:
-            ensure_button_arrow_widget();
-            widget = gButtonArrowWidget;
-            break;
-    }
-
-    GtkRequisition requisition;
-    gtk_widget_size_request(widget, &requisition);
-    *width = requisition.width;
-    *height = requisition.height;
-}
-
-gint
-moz_gtk_get_toolbar_separator_width(gint* size)
-{
-    gboolean wide_separators;
-    gint separator_width;
-    GtkStyle* style;
-
-    ensure_toolbar_widget();
-
-    style = gToolbarWidget->style;
-
-    gtk_widget_style_get(gToolbarWidget,
-                         "space-size", size,
-                         "wide-separators",  &wide_separators,
-                         "separator-width", &separator_width,
-                         NULL);
-
-    /* Just in case... */
-    *size = MAX(*size, (wide_separators ? separator_width : style->xthickness));
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_get_expander_size(gint* size)
-{
-    ensure_expander_widget();
-    gtk_widget_style_get(gExpanderWidget,
-                         "expander-size", size,
-                         NULL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_get_treeview_expander_size(gint* size)
-{
-    ensure_tree_view_widget();
-    gtk_widget_style_get(gTreeViewWidget,
-                         "expander-size", size,
-                         NULL);
-
-    return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_get_menu_separator_height(gint *size)
-{
-    gboolean wide_separators;
-    gint     separator_height;
-
-    ensure_menu_separator_widget();
-
-    gtk_widget_style_get(gMenuSeparatorWidget,
-                          "wide-separators",  &wide_separators,
-                          "separator-height", &separator_height,
-                          NULL);
-
-    if (wide_separators)
-        *size = separator_height + gMenuSeparatorWidget->style->ythickness;
-    else
-        *size = gMenuSeparatorWidget->style->ythickness * 2;
-
-    return MOZ_GTK_SUCCESS;
-}
-
-void
-moz_gtk_get_scale_metrics(GtkOrientation orient, gint* scale_width,
-                          gint* scale_height)
-{
-  moz_gtk_get_scalethumb_metrics(orient, scale_width, scale_height);
-}
-
-
-gint
-moz_gtk_get_scalethumb_metrics(GtkOrientation orient, gint* thumb_length, gint* thumb_height)
-{
-  GtkWidget* widget;
-
-  ensure_scale_widget();
-  widget = ((orient == GTK_ORIENTATION_HORIZONTAL) ? gHScaleWidget : gVScaleWidget);
-
-  gtk_widget_style_get (widget,
-                        "slider_length", thumb_length,
-                        "slider_width", thumb_height,
-                        NULL);
-
-  return MOZ_GTK_SUCCESS;
-}
-
-gint
-moz_gtk_get_scrollbar_metrics(MozGtkScrollbarMetrics *metrics)
-{
-    ensure_scrollbar_widget();
-
-    gtk_widget_style_get (gHorizScrollbarWidget,
-                          "slider_width", &metrics->slider_width,
-                          "trough_border", &metrics->trough_border,
-                          "stepper_size", &metrics->stepper_size,
-                          "stepper_spacing", &metrics->stepper_spacing,
-                          NULL);
-
-    metrics->min_slider_size =
-        GTK_RANGE(gHorizScrollbarWidget)->min_slider_size;
-
-    return MOZ_GTK_SUCCESS;
-}
-void
-moz_gtk_get_widget_min_size(WidgetNodeType aGtkWidgetType, int* width, int* height) {
-  MOZ_ASSERT_UNREACHABLE("get_widget_min_size not available for GTK2");
-}
-
-gint
-moz_gtk_widget_paint(WidgetNodeType widget, GdkDrawable* drawable,
-                     GdkRectangle* rect, GdkRectangle* cliprect,
-                     GtkWidgetState* state, gint flags,
-                     GtkTextDirection direction)
-{
-    switch (widget) {
-    case MOZ_GTK_BUTTON:
-    case MOZ_GTK_TOOLBAR_BUTTON:
-        if (state->depressed) {
-            ensure_toggle_button_widget();
-            return moz_gtk_button_paint(drawable, rect, cliprect, state,
-                                        (GtkReliefStyle) flags,
-                                        gToggleButtonWidget, direction);
-        }
-        ensure_button_widget();
-        return moz_gtk_button_paint(drawable, rect, cliprect, state,
-                                    (GtkReliefStyle) flags, gButtonWidget,
-                                    direction);
-        break;
-    case MOZ_GTK_CHECKBUTTON:
-    case MOZ_GTK_RADIOBUTTON:
-        return moz_gtk_toggle_paint(drawable, rect, cliprect, state,
-                                    !!(flags & MOZ_GTK_WIDGET_CHECKED),
-                                    !!(flags & MOZ_GTK_WIDGET_INCONSISTENT),
-                                    (widget == MOZ_GTK_RADIOBUTTON),
-                                    direction);
-        break;
-    case MOZ_GTK_SCROLLBAR_BUTTON:
-        return moz_gtk_scrollbar_button_paint(drawable, rect, cliprect, state,
-                                              (GtkScrollbarButtonFlags) flags,
-                                              direction);
-        break;
-    case MOZ_GTK_SCROLLBAR_HORIZONTAL:
-    case MOZ_GTK_SCROLLBAR_VERTICAL:
-        return moz_gtk_scrollbar_trough_paint(widget, drawable, rect,
-                                              cliprect, state, direction);
-        break;
-    case MOZ_GTK_SCROLLBAR_TROUGH_HORIZONTAL:
-    case MOZ_GTK_SCROLLBAR_TROUGH_VERTICAL:
-        return MOZ_GTK_SUCCESS;
-        break;
-    case MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL:
-    case MOZ_GTK_SCROLLBAR_THUMB_VERTICAL:
-        return moz_gtk_scrollbar_thumb_paint(widget, drawable, rect,
-                                             cliprect, state, direction);
-        break;
-    case MOZ_GTK_SCALE_HORIZONTAL:
-    case MOZ_GTK_SCALE_VERTICAL:
-        return moz_gtk_scale_paint(drawable, rect, cliprect, state,
-                                   (GtkOrientation) flags, direction);
-        break;
-    case MOZ_GTK_SCALE_THUMB_HORIZONTAL:
-    case MOZ_GTK_SCALE_THUMB_VERTICAL:
-        return moz_gtk_scale_thumb_paint(drawable, rect, cliprect, state,
-                                         (GtkOrientation) flags, direction);
-        break;
-    case MOZ_GTK_INNER_SPIN_BUTTON:
-        return moz_gtk_inner_spin_paint(drawable, rect, state, direction);
-        break;
-    case MOZ_GTK_SPINBUTTON:
-        return moz_gtk_spin_paint(drawable, rect, direction);
-        break;
-    case MOZ_GTK_SPINBUTTON_UP:
-    case MOZ_GTK_SPINBUTTON_DOWN:
-        return moz_gtk_spin_updown_paint(drawable, rect,
-                                         (widget == MOZ_GTK_SPINBUTTON_DOWN),
-                                         state, direction);
-        break;
-    case MOZ_GTK_SPINBUTTON_ENTRY:
-        ensure_spin_widget();
-        return moz_gtk_entry_paint(drawable, rect, cliprect, state,
-                                   gSpinWidget, direction);
-        break;
-    case MOZ_GTK_GRIPPER:
-        return moz_gtk_gripper_paint(drawable, rect, cliprect, state,
-                                     direction);
-        break;
-    case MOZ_GTK_TREEVIEW:
-        return moz_gtk_treeview_paint(drawable, rect, cliprect, state,
-                                      direction);
-        break;
-    case MOZ_GTK_TREE_HEADER_CELL:
-        return moz_gtk_tree_header_cell_paint(drawable, rect, cliprect, state,
-                                              flags, direction);
-        break;
-    case MOZ_GTK_TREE_HEADER_SORTARROW:
-        return moz_gtk_tree_header_sort_arrow_paint(drawable, rect, cliprect,
-                                                    state,
-                                                    (GtkArrowType) flags,
-                                                    direction);
-        break;
-    case MOZ_GTK_TREEVIEW_EXPANDER:
-        return moz_gtk_treeview_expander_paint(drawable, rect, cliprect, state,
-                                               (GtkExpanderStyle) flags, direction);
-        break;
-    case MOZ_GTK_ENTRY:
-        ensure_entry_widget();
-        return moz_gtk_entry_paint(drawable, rect, cliprect, state,
-                                   gEntryWidget, direction);
-        break;
-    case MOZ_GTK_DROPDOWN:
-        return moz_gtk_combo_box_paint(drawable, rect, cliprect, state,
-                                       (gboolean) flags, direction);
-        break;
-    case MOZ_GTK_DROPDOWN_ARROW:
-        return moz_gtk_combo_box_entry_button_paint(drawable, rect, cliprect,
-                                                    state, flags, direction);
-        break;
-    case MOZ_GTK_DROPDOWN_ENTRY:
-        ensure_combo_box_entry_widgets();
-        return moz_gtk_entry_paint(drawable, rect, cliprect, state,
-                                   gComboBoxEntryTextareaWidget, direction);
-        break;
-    case MOZ_GTK_CHECKBUTTON_CONTAINER:
-    case MOZ_GTK_RADIOBUTTON_CONTAINER:
-        return moz_gtk_container_paint(drawable, rect, cliprect, state,
-                                       (widget == MOZ_GTK_RADIOBUTTON_CONTAINER),
-                                       direction);
-        break;
-    case MOZ_GTK_CHECKBUTTON_LABEL:
-    case MOZ_GTK_RADIOBUTTON_LABEL:
-        return moz_gtk_toggle_label_paint(drawable, rect, cliprect, state,
-                                          (widget == MOZ_GTK_RADIOBUTTON_LABEL),
-                                          direction);
-        break;
-    case MOZ_GTK_TOOLBAR:
-        return moz_gtk_toolbar_paint(drawable, rect, cliprect, direction);
-        break;
-    case MOZ_GTK_TOOLBAR_SEPARATOR:
-        return moz_gtk_toolbar_separator_paint(drawable, rect, cliprect,
-                                               direction);
-        break;
-    case MOZ_GTK_TOOLTIP:
-        return moz_gtk_tooltip_paint(drawable, rect, cliprect, direction);
-        break;
-    case MOZ_GTK_FRAME:
-        return moz_gtk_frame_paint(drawable, rect, cliprect, direction);
-        break;
-    case MOZ_GTK_RESIZER:
-        return moz_gtk_resizer_paint(drawable, rect, cliprect, state,
-                                     direction);
-        break;
-    case MOZ_GTK_PROGRESSBAR:
-        return moz_gtk_progressbar_paint(drawable, rect, cliprect, direction);
-        break;
-    case MOZ_GTK_PROGRESS_CHUNK:
-    case MOZ_GTK_PROGRESS_CHUNK_INDETERMINATE:
-    case MOZ_GTK_PROGRESS_CHUNK_VERTICAL_INDETERMINATE:
-        return moz_gtk_progress_chunk_paint(drawable, rect, cliprect,
-                                            direction, widget);
-        break;
-    case MOZ_GTK_TAB_TOP:
-    case MOZ_GTK_TAB_BOTTOM:
-        return moz_gtk_tab_paint(drawable, rect, cliprect, state,
-                                 (GtkTabFlags) flags, direction, widget);
-        break;
-    case MOZ_GTK_TABPANELS:
-        return moz_gtk_tabpanels_paint(drawable, rect, cliprect, direction);
-        break;
-    case MOZ_GTK_TAB_SCROLLARROW:
-        return moz_gtk_tab_scroll_arrow_paint(drawable, rect, cliprect, state,
-                                              (GtkArrowType) flags, direction);
-        break;
-    case MOZ_GTK_MENUBAR:
-        return moz_gtk_menu_bar_paint(drawable, rect, cliprect, direction);
-        break;
-    case MOZ_GTK_MENUPOPUP:
-        return moz_gtk_menu_popup_paint(drawable, rect, cliprect, direction);
-        break;
-    case MOZ_GTK_MENUSEPARATOR:
-        return moz_gtk_menu_separator_paint(drawable, rect, cliprect,
-                                            direction);
-        break;
-    case MOZ_GTK_MENUBARITEM:
-    case MOZ_GTK_MENUITEM:
-        return moz_gtk_menu_item_paint(widget, drawable, rect, cliprect, state,
-                                       direction);
-        break;
-    case MOZ_GTK_MENUARROW:
-        return moz_gtk_menu_arrow_paint(drawable, rect, cliprect, state,
-                                        direction);
-        break;
-    case MOZ_GTK_TOOLBARBUTTON_ARROW:
-        return moz_gtk_arrow_paint(drawable, rect, cliprect, state,
-                                   (GtkArrowType) flags, direction);
-        break;
-    case MOZ_GTK_CHECKMENUITEM:
-    case MOZ_GTK_RADIOMENUITEM:
-        return moz_gtk_check_menu_item_paint(drawable, rect, cliprect, state,
-                                             (gboolean) flags,
-                                             (widget == MOZ_GTK_RADIOMENUITEM),
-                                             direction);
-        break;
-    case MOZ_GTK_SPLITTER_HORIZONTAL:
-        return moz_gtk_vpaned_paint(drawable, rect, cliprect, state);
-        break;
-    case MOZ_GTK_SPLITTER_VERTICAL:
-        return moz_gtk_hpaned_paint(drawable, rect, cliprect, state);
-        break;
-    case MOZ_GTK_WINDOW:
-        return moz_gtk_window_paint(drawable, rect, cliprect, direction);
-        break;
-    default:
-        g_warning("Unknown widget type: %d", widget);
-    }
-
-    return MOZ_GTK_UNKNOWN_WIDGET;
-}
-
-GtkWidget* moz_gtk_get_scrollbar_widget(void)
-{
-    MOZ_ASSERT(is_initialized, "Forgot to call moz_gtk_init()");
-    ensure_scrollbar_widget();
-    return gHorizScrollbarWidget;
-}
-
-gboolean moz_gtk_has_scrollbar_buttons(void)
-{
-    gboolean backward, forward, secondary_backward, secondary_forward;
-    MOZ_ASSERT(is_initialized, "Forgot to call moz_gtk_init()");
-    ensure_scrollbar_widget();
-    gtk_widget_style_get (gHorizScrollbarWidget,
-                          "has-backward-stepper", &backward,
-                          "has-forward-stepper", &forward,
-                          "has-secondary-backward-stepper", &secondary_backward,
-                          "has-secondary-forward-stepper", &secondary_forward,
-                          NULL);
-    return backward | forward | secondary_forward | secondary_forward;
-}
-
-gint
-moz_gtk_shutdown()
-{
-    GtkWidgetClass *entry_class;
-
-    if (gTooltipWidget)
-        gtk_widget_destroy(gTooltipWidget);
-    /* This will destroy all of our widgets */
-    if (gProtoWindow)
-        gtk_widget_destroy(gProtoWindow);
-
-    gProtoWindow = NULL;
-    gProtoLayout = NULL;
-    gButtonWidget = NULL;
-    gToggleButtonWidget = NULL;
-    gButtonArrowWidget = NULL;
-    gCheckboxWidget = NULL;
-    gRadiobuttonWidget = NULL;
-    gHorizScrollbarWidget = NULL;
-    gVertScrollbarWidget = NULL;
-    gSpinWidget = NULL;
-    gHScaleWidget = NULL;
-    gVScaleWidget = NULL;
-    gEntryWidget = NULL;
-    gComboBoxWidget = NULL;
-    gComboBoxButtonWidget = NULL;
-    gComboBoxSeparatorWidget = NULL;
-    gComboBoxArrowWidget = NULL;
-    gComboBoxEntryWidget = NULL;
-    gComboBoxEntryButtonWidget = NULL;
-    gComboBoxEntryArrowWidget = NULL;
-    gComboBoxEntryTextareaWidget = NULL;
-    gHandleBoxWidget = NULL;
-    gToolbarWidget = NULL;
-    gStatusbarWidget = NULL;
-    gFrameWidget = NULL;
-    gProgressWidget = NULL;
-    gTabWidget = NULL;
-    gTooltipWidget = NULL;
-    gMenuBarWidget = NULL;
-    gMenuBarItemWidget = NULL;
-    gMenuPopupWidget = NULL;
-    gMenuItemWidget = NULL;
-    gCheckMenuItemWidget = NULL;
-    gTreeViewWidget = NULL;
-    gMiddleTreeViewColumn = NULL;
-    gTreeHeaderCellWidget = NULL;
-    gTreeHeaderSortArrowWidget = NULL;
-    gExpanderWidget = NULL;
-    gToolbarSeparatorWidget = NULL;
-    gMenuSeparatorWidget = NULL;
-    gHPanedWidget = NULL;
-    gVPanedWidget = NULL;
-    gScrolledWindowWidget = NULL;
-
-    entry_class = g_type_class_peek(GTK_TYPE_ENTRY);
-    g_type_class_unref(entry_class);
-
-    is_initialized = FALSE;
-
-    return MOZ_GTK_SUCCESS;
-}
--- a/widget/gtk/moz.build
+++ b/widget/gtk/moz.build
@@ -103,26 +103,21 @@ if CONFIG['MOZ_WAYLAND']:
         'WindowSurfaceWayland.cpp',
     ]
 
 if CONFIG['ACCESSIBILITY']:
     UNIFIED_SOURCES += [
         'maiRedundantObjectFactory.c',
     ]
 
-if CONFIG['MOZ_WIDGET_TOOLKIT'] == 'gtk2':
-    UNIFIED_SOURCES += [
-        'gtk2drawing.c',
-    ]
-else:
-    UNIFIED_SOURCES += [
-        'gtk3drawing.cpp',
-        'nsApplicationChooser.cpp',
-        'WidgetStyleCache.cpp',
-    ]
+UNIFIED_SOURCES += [
+    'gtk3drawing.cpp',
+    'nsApplicationChooser.cpp',
+    'WidgetStyleCache.cpp',
+]
 
 include('/ipc/chromium/chromium-config.mozbuild')
 
 FINAL_LIBRARY = 'xul'
 
 LOCAL_INCLUDES += [
     '/layout/base',
     '/layout/generic',
--- a/widget/windows/nsNativeThemeWin.cpp
+++ b/widget/windows/nsNativeThemeWin.cpp
@@ -137,16 +137,24 @@ static MARGINS
 GetCheckboxMargins(HANDLE theme, HDC hdc)
 {
     MARGINS checkboxContent = {0};
     GetThemeMargins(theme, hdc, MENU_POPUPCHECK, MCB_NORMAL,
                     TMT_CONTENTMARGINS, nullptr, &checkboxContent);
     return checkboxContent;
 }
 
+static COLORREF
+GetTextfieldFillColor(HANDLE theme, int32_t part, int32_t state)
+{
+    COLORREF color = {0};
+    GetThemeColor(theme, part, state, TMT_FILLCOLOR, &color);
+    return color;
+}
+
 static SIZE
 GetCheckboxBGSize(HANDLE theme, HDC hdc)
 {
     SIZE checkboxSize;
     GetThemePartSize(theme, hdc, MENU_POPUPCHECK, MC_CHECKMARKNORMAL,
                      nullptr, TS_TRUE, &checkboxSize);
 
     MARGINS checkboxMargins = GetCheckboxMargins(theme, hdc);
@@ -1870,21 +1878,29 @@ RENDER_AGAIN:
   {
     DrawThemeBGRTLAware(theme, hdc, part, state,
                         &widgetRect, &clipRect, IsFrameRTL(aFrame));
   }
   else if (aWidgetType == StyleAppearance::MenulistTextfield ||
            aWidgetType == StyleAppearance::NumberInput ||
            aWidgetType == StyleAppearance::Textfield ||
            aWidgetType == StyleAppearance::TextfieldMultiline) {
-    // Paint the border, except for 'menulist-textfield' that isn't focused:
-    if (aWidgetType != StyleAppearance::MenulistTextfield ||
-        state == TFS_EDITBORDER_FOCUSED) {
+    if (aWidgetType == StyleAppearance::MenulistTextfield &&
+        state != TFS_EDITBORDER_FOCUSED) {
+      // We want 'menulist-textfield' to behave like 'textfield', except we
+      // don't want a border unless it's focused.  We have to handle the
+      // non-focused case manually here.
+      COLORREF color = GetTextfieldFillColor(theme, part, state);
+      HBRUSH brush = CreateSolidBrush(color);
+      ::FillRect(hdc, &widgetRect, brush);
+      DeleteObject(brush);
+    } else {
       DrawThemeBackground(theme, hdc, part, state, &widgetRect, &clipRect);
     }
+
     if (state == TFS_EDITBORDER_DISABLED) {
       InflateRect(&widgetRect, -1, -1);
       ::FillRect(hdc, &widgetRect, reinterpret_cast<HBRUSH>(COLOR_BTNFACE+1));
     }
   }
   else if (aWidgetType == StyleAppearance::Progressbar ||
            aWidgetType == StyleAppearance::ProgressbarVertical) {
     // DrawThemeBackground renders each corner with a solid white pixel.