Attachment 820130 Details for Bug 757726

[patch] part-5-hide-plugins.patch

757726-part-5-hide-plugins.patch (text/plain), 18.14 KB, created by Chris Peterson [:cpeterson]

(hide)

Description:

Filename:

MIME Type:

Creator: Chris Peterson [:cpeterson]

Size: 18.14 KB

patch

obsolete

># HG changeset patch
># Parent c333cd89f768c4751692b8c4ad5c6a89275ea83f
># User Chris Peterson <cpeterson@mozilla.com>
># Date 1382207331 25200
>
>Bug 757726 - Part 5: Hide most plugins from navigator.plugins and navigator.mimeTypes enumeration. r=
>
>diff --git a/dom/base/nsMimeTypeArray.cpp b/dom/base/nsMimeTypeArray.cpp
>--- a/dom/base/nsMimeTypeArray.cpp
>+++ b/dom/base/nsMimeTypeArray.cpp
>@@ -20,23 +20,23 @@ using namespace mozilla::dom;
> 
> NS_IMPL_CYCLE_COLLECTING_ADDREF(nsMimeTypeArray)
> NS_IMPL_CYCLE_COLLECTING_RELEASE(nsMimeTypeArray)
> NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsMimeTypeArray)
>   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
>   NS_INTERFACE_MAP_ENTRY(nsISupports)
> NS_INTERFACE_MAP_END
> 
>-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_2(nsMimeTypeArray,
>+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_3(nsMimeTypeArray,
>                                         mWindow,
>-                                        mMimeTypes)
>+                                        mMimeTypes,
>+                                        mHiddenMimeTypes)
> 
> nsMimeTypeArray::nsMimeTypeArray(nsPIDOMWindow* aWindow)
>-  : mWindow(aWindow),
>-    mPluginMimeTypeCount(0)
>+  : mWindow(aWindow)
> {
>   SetIsDOMBinding();
> }
> 
> nsMimeTypeArray::~nsMimeTypeArray()
> {
> }
> 
>@@ -45,17 +45,17 @@ nsMimeTypeArray::WrapObject(JSContext* a
> {
>   return MimeTypeArrayBinding::Wrap(aCx, aScope, this);
> }
> 
> void
> nsMimeTypeArray::Refresh()
> {
>   mMimeTypes.Clear();
>-  mPluginMimeTypeCount = 0;
>+  mHiddenMimeTypes.Clear();
> }
> 
> nsPIDOMWindow*
> nsMimeTypeArray::GetParentObject() const
> {
>   MOZ_ASSERT(mWindow);
>   return mWindow;
> }
>@@ -76,40 +76,54 @@ nsMimeTypeArray::NamedItem(const nsAStri
> 
> nsMimeType*
> nsMimeTypeArray::IndexedGetter(uint32_t aIndex, bool &aFound)
> {
>   aFound = false;
> 
>   EnsureMimeTypes();
> 
>-  MOZ_ASSERT(mMimeTypes.Length() >= mPluginMimeTypeCount);
>-
>-  if (aIndex >= mPluginMimeTypeCount) {
>+  if (aIndex >= mMimeTypes.Length()) {
>     return nullptr;
>   }
> 
>   aFound = true;
> 
>   return mMimeTypes[aIndex];
> }
> 
>+static nsMimeType*
>+FindMimeType(const nsTArray<nsRefPtr<nsMimeType> >& aMimeTypes,
>+             const nsAString& aType)
>+{
>+  for (uint32_t i = 0; i < aMimeTypes.Length(); ++i) {
>+    nsMimeType* mimeType = aMimeTypes[i];
>+    if (aType.Equals(mimeType->Type())) {
>+      return mimeType;
>+    }
>+  }
>+
>+  return nullptr;
>+}
>+
> nsMimeType*
> nsMimeTypeArray::NamedGetter(const nsAString& aName, bool &aFound)
> {
>   aFound = false;
> 
>   EnsureMimeTypes();
> 
>-  for (uint32_t i = 0; i < mMimeTypes.Length(); ++i) {
>-    if (aName.Equals(mMimeTypes[i]->Type())) {
>-      aFound = true;
>+  nsMimeType* mimeType = FindMimeType(mMimeTypes, aName);
>+  if (!mimeType) {
>+    mimeType = FindMimeType(mHiddenMimeTypes, aName);
>+  }
> 
>-      return mMimeTypes[i];
>-    }
>+  if (mimeType) {
>+    aFound = true;
>+    return mimeType;
>   }
> 
>   // Now let's check with the MIME service.
>   nsCOMPtr<nsIMIMEService> mimeSrv = do_GetService("@mozilla.org/mime;1");
>   if (!mimeSrv) {
>     return nullptr;
>   }
> 
>@@ -143,46 +157,46 @@ nsMimeTypeArray::NamedGetter(const nsASt
>         }
>       }
>     }
>   }
> 
>   // If we got here, we support this type!  Say so.
>   aFound = true;
> 
>+  // We don't want navigator.mimeTypes enumeration to expose MIME types with
>+  // application handlers, so add them to the list of hidden MIME types.
>   nsMimeType *mt = new nsMimeType(mWindow, aName);
>-  mMimeTypes.AppendElement(mt);
>+  mHiddenMimeTypes.AppendElement(mt);
> 
>   return mt;
> }
> 
> uint32_t
> nsMimeTypeArray::Length()
> {
>   EnsureMimeTypes();
> 
>-  MOZ_ASSERT(mMimeTypes.Length() >= mPluginMimeTypeCount);
>-
>-  return mPluginMimeTypeCount;
>+  return mMimeTypes.Length();
> }
> 
> void
> nsMimeTypeArray::GetSupportedNames(nsTArray< nsString >& aRetval)
> {
>   EnsureMimeTypes();
> 
>   for (uint32_t i = 0; i < mMimeTypes.Length(); ++i) {
>     aRetval.AppendElement(mMimeTypes[i]->Type());
>   }
> }
> 
> void
> nsMimeTypeArray::EnsureMimeTypes()
> {
>-  if (!mMimeTypes.IsEmpty() || !mWindow) {
>+  if (!mMimeTypes.IsEmpty() || !mHiddenMimeTypes.IsEmpty() || !mWindow) {
>     return;
>   }
> 
>   nsCOMPtr<nsIDOMNavigator> navigator;
>   mWindow->GetNavigator(getter_AddRefs(navigator));
> 
>   if (!navigator) {
>     return;
>@@ -190,19 +204,17 @@ nsMimeTypeArray::EnsureMimeTypes()
> 
>   ErrorResult rv;
>   nsPluginArray *pluginArray =
>     static_cast<Navigator*>(navigator.get())->GetPlugins(rv);
>   if (!pluginArray) {
>     return;
>   }
> 
>-  pluginArray->GetMimeTypes(mMimeTypes);
>-
>-  mPluginMimeTypeCount = mMimeTypes.Length();
>+  pluginArray->GetMimeTypes(mMimeTypes, mHiddenMimeTypes);
> }
> 
> NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(nsMimeType, AddRef)
> NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(nsMimeType, Release)
> 
> NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_2(nsMimeType, mWindow, mPluginElement)
> 
> nsMimeType::nsMimeType(nsPIDOMWindow* aWindow, nsPluginElement* aPluginElement,
>diff --git a/dom/base/nsMimeTypeArray.h b/dom/base/nsMimeTypeArray.h
>--- a/dom/base/nsMimeTypeArray.h
>+++ b/dom/base/nsMimeTypeArray.h
>@@ -45,21 +45,17 @@ protected:
>   void Clear();
> 
>   nsCOMPtr<nsPIDOMWindow> mWindow;
> 
>   // mMimeTypes contains all mime types handled by plugins followed by
>   // any other mime types that we handle internally and have been
>   // looked up before.
>   nsTArray<nsRefPtr<nsMimeType> > mMimeTypes;
>-
>-  // mPluginMimeTypeCount is the number of plugin mime types that we
>-  // have in mMimeTypes. The plugin mime types are always at the
>-  // beginning of the list.
>-  uint32_t mPluginMimeTypeCount;
>+  nsTArray<nsRefPtr<nsMimeType> > mHiddenMimeTypes;
> };
> 
> class nsMimeType MOZ_FINAL : public nsWrapperCache
> {
> public:
>   NS_INLINE_DECL_CYCLE_COLLECTING_NATIVE_REFCOUNTING(nsMimeType)
>   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_NATIVE_CLASS(nsMimeType)
> 
>diff --git a/dom/base/nsPluginArray.cpp b/dom/base/nsPluginArray.cpp
>--- a/dom/base/nsPluginArray.cpp
>+++ b/dom/base/nsPluginArray.cpp
>@@ -58,35 +58,46 @@ NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPlugin
> NS_IMPL_CYCLE_COLLECTING_RELEASE(nsPluginArray)
> NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPluginArray)
>   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
>   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, nsIObserver)
>   NS_INTERFACE_MAP_ENTRY(nsIObserver)
>   NS_INTERFACE_MAP_ENTRY(nsISupportsWeakReference)
> NS_INTERFACE_MAP_END
> 
>-NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_2(nsPluginArray,
>+NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_3(nsPluginArray,
>                                         mWindow,
>-                                        mPlugins)
>+                                        mPlugins,
>+                                        mHiddenPlugins)
>+
>+static void
>+GetPluginMimeTypes(const nsTArray<nsRefPtr<nsPluginElement> >& aPlugins,
>+                   nsTArray<nsRefPtr<nsMimeType> >& aMimeTypes)
>+{
>+  for (uint32_t i = 0; i < aPlugins.Length(); ++i) {
>+    nsPluginElement *plugin = aPlugins[i];
>+    aMimeTypes.AppendElements(plugin->MimeTypes());
>+  }
>+}
> 
> void
>-nsPluginArray::GetMimeTypes(nsTArray<nsRefPtr<nsMimeType> >& aMimeTypes)
>+nsPluginArray::GetMimeTypes(nsTArray<nsRefPtr<nsMimeType> >& aMimeTypes,
>+                            nsTArray<nsRefPtr<nsMimeType> >& aHiddenMimeTypes)
> {
>   aMimeTypes.Clear();
>+  aHiddenMimeTypes.Clear();
> 
>   if (!AllowPlugins()) {
>     return;
>   }
> 
>   EnsurePlugins();
> 
>-  for (uint32_t i = 0; i < mPlugins.Length(); ++i) {
>-    nsPluginElement *plugin = mPlugins[i];
>-    aMimeTypes.AppendElements(plugin->MimeTypes());
>-  }
>+  GetPluginMimeTypes(mPlugins, aMimeTypes);
>+  GetPluginMimeTypes(mHiddenPlugins, aHiddenMimeTypes);
> }
> 
> nsPluginElement*
> nsPluginArray::Item(uint32_t aIndex)
> {
>   bool unused;
>   return IndexedGetter(aIndex, unused);
> }
>@@ -116,22 +127,24 @@ nsPluginArray::Refresh(bool aReloadDocum
> 
>     // Check if the number of plugins we know about are different from
>     // the number of plugin tags the plugin host knows about. If the
>     // lengths are different, we refresh. This is safe because we're
>     // notified for every plugin enabling/disabling event that
>     // happens, and therefore the lengths will be in sync only when
>     // the both arrays contain the same plugin tags (though as
>     // different types).
>-    if (newPluginTags.Length() == mPlugins.Length()) {
>+    uint32_t pluginCount = mPlugins.Length() + mHiddenPlugins.Length();
>+    if (newPluginTags.Length() == pluginCount) {
>       return;
>     }
>   }
> 
>   mPlugins.Clear();
>+  mHiddenPlugins.Clear();
> 
>   nsCOMPtr<nsIDOMNavigator> navigator;
>   mWindow->GetNavigator(getter_AddRefs(navigator));
> 
>   if (!navigator) {
>     return;
>   }
> 
>@@ -164,40 +177,51 @@ nsPluginArray::Invalidate()
> {
>   nsCOMPtr<nsIObserverService> obsService =
>     mozilla::services::GetObserverService();
>   if (obsService) {
>     obsService->RemoveObserver(this, "plugin-info-updated");
>   }
> }
> 
>+static nsPluginElement*
>+FindPlugin(const nsTArray<nsRefPtr<nsPluginElement> >& aPlugins,
>+           const nsAString& aName)
>+{
>+  for (uint32_t i = 0; i < aPlugins.Length(); ++i) {
>+    nsAutoString pluginName;
>+    nsPluginElement* plugin = aPlugins[i];
>+    plugin->GetName(pluginName);
>+
>+    if (pluginName.Equals(aName)) {
>+      return plugin;
>+    }
>+  }
>+
>+  return nullptr;
>+}
>+
> nsPluginElement*
> nsPluginArray::NamedGetter(const nsAString& aName, bool &aFound)
> {
>   aFound = false;
> 
>   if (!AllowPlugins()) {
>     return nullptr;
>   }
> 
>   EnsurePlugins();
> 
>-  for (uint32_t i = 0; i < mPlugins.Length(); ++i) {
>-    nsAutoString pluginName;
>-    nsPluginElement* plugin = mPlugins[i];
>-    plugin->GetName(pluginName);
>-
>-    if (pluginName.Equals(aName)) {
>-      aFound = true;
>-
>-      return plugin;
>-    }
>+  nsPluginElement* plugin = FindPlugin(mPlugins, aName);
>+  if (!plugin) {
>+    plugin = FindPlugin(mHiddenPlugins, aName);
>   }
> 
>-  return nullptr;
>+  aFound = (plugin != nullptr);
>+  return plugin;
> }
> 
> uint32_t
> nsPluginArray::Length()
> {
>   if (!AllowPlugins()) {
>     return 0;
>   }
>@@ -237,37 +261,53 @@ nsPluginArray::Observe(nsISupports *aSub
> bool
> nsPluginArray::AllowPlugins() const
> {
>   nsCOMPtr<nsIDocShell> docShell = do_GetInterface(mWindow);
> 
>   return docShell && docShell->PluginsAllowedInCurrentDoc();
> }
> 
>+static bool
>+IsPluginHidable(const nsPluginTag* pluginTag)
>+{
>+  const nsCString& pluginName = pluginTag->mName;
>+
>+  return !pluginName.Equals("Shockwave Flash") &&
>+         !pluginName.Equals("Java Applet Plug-in") &&
>+         !pluginName.Equals("Second Test Plug-in"); // UNHIDE PLUGIN FOR TESTS
>+}
>+
> void
> nsPluginArray::EnsurePlugins()
> {
>-  if (!mPlugins.IsEmpty()) {
>+  if (!mPlugins.IsEmpty() || !mHiddenPlugins.IsEmpty()) {
>     // We already have an array of plugin elements.
>     return;
>   }
> 
>   nsRefPtr<nsPluginHost> pluginHost = nsPluginHost::GetInst();
>   if (!pluginHost) {
>     // We have no plugin host.
>     return;
>   }
> 
>   nsTArray<nsRefPtr<nsPluginTag> > pluginTags;
>   pluginHost->GetPlugins(pluginTags);
> 
>   // need to wrap each of these with a nsPluginElement, which is
>   // scriptable.
>   for (uint32_t i = 0; i < pluginTags.Length(); ++i) {
>-    mPlugins.AppendElement(new nsPluginElement(mWindow, pluginTags[i]));
>+    nsPluginTag* pluginTag = pluginTags[i];
>+
>+    // Add the plugin to the list of hidden or non-hidden plugins?
>+    nsTArray<nsRefPtr<nsPluginElement> >& pluginArray =
>+        IsPluginHidable(pluginTag) ? mHiddenPlugins : mPlugins;
>+
>+    pluginArray.AppendElement(new nsPluginElement(mWindow, pluginTag));
>   }
> }
> 
> // nsPluginElement implementation.
> 
> NS_IMPL_CYCLE_COLLECTING_ADDREF(nsPluginElement)
> NS_IMPL_CYCLE_COLLECTING_RELEASE(nsPluginElement)
> NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsPluginElement)
>diff --git a/dom/base/nsPluginArray.h b/dom/base/nsPluginArray.h
>--- a/dom/base/nsPluginArray.h
>+++ b/dom/base/nsPluginArray.h
>@@ -38,17 +38,18 @@ public:
> 
>   // nsPluginArray registers itself as an observer with a weak reference.
>   // This can't be done in the constructor, because at that point its
>   // refcount is 0 (and it gets destroyed upon registration). So, Init()
>   // must be called after construction.
>   void Init();
>   void Invalidate();
> 
>-  void GetMimeTypes(nsTArray<nsRefPtr<nsMimeType> >& aMimeTypes);
>+  void GetMimeTypes(nsTArray<nsRefPtr<nsMimeType> >& aMimeTypes,
>+                    nsTArray<nsRefPtr<nsMimeType> >& aHiddenMimeTypes);
> 
>   // PluginArray WebIDL methods
> 
>   nsPluginElement* Item(uint32_t aIndex);
>   nsPluginElement* NamedItem(const nsAString& aName);
>   void Refresh(bool aReloadDocuments);
>   nsPluginElement* IndexedGetter(uint32_t aIndex, bool &aFound);
>   nsPluginElement* NamedGetter(const nsAString& aName, bool &aFound);
>@@ -56,16 +57,17 @@ public:
>   void GetSupportedNames(nsTArray< nsString >& aRetval);
> 
> private:
>   bool AllowPlugins() const;
>   void EnsurePlugins();
> 
>   nsCOMPtr<nsPIDOMWindow> mWindow;
>   nsTArray<nsRefPtr<nsPluginElement> > mPlugins;
>+  nsTArray<nsRefPtr<nsPluginElement> > mHiddenPlugins;
> };
> 
> class nsPluginElement MOZ_FINAL : public nsISupports,
>                                   public nsWrapperCache
> {
> public:
>   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
>   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS(nsPluginElement)
>diff --git a/dom/plugins/test/mochitest/test_secondPlugin.html b/dom/plugins/test/mochitest/test_secondPlugin.html
>--- a/dom/plugins/test/mochitest/test_secondPlugin.html
>+++ b/dom/plugins/test/mochitest/test_secondPlugin.html
>@@ -9,28 +9,52 @@
> 
>   <body onload="run()">
>     <script class="testbody" type="application/javascript">
>       SimpleTest.waitForExplicitFinish();
>       setTestPluginEnabledState(SpecialPowers.Ci.nsIPluginTag.STATE_ENABLED);
>       setTestPluginEnabledState(SpecialPowers.Ci.nsIPluginTag.STATE_ENABLED, "Second Test Plug-in");
> 
>       function run() {
>+        "use strict";
>+
>+        //
>+        // Test hidden and non-hidden plugins.
>+        //
>+        ok(navigator.plugins["Test Plug-in"], "Should have a plugin named 'Test Plug-in'");
>+        ok(navigator.plugins["Second Test Plug-in"], "Should have a plugin named 'Second Test Plug-in'");
>+
>         var foundFirstPlugin = false;
>         var foundSecondPlugin = false;
>         for (var index in navigator.plugins) {
>           var plugin = navigator.plugins[index];
>           if (plugin.name == "Test Plug-in") foundFirstPlugin = true;
>           if (plugin.name == "Second Test Plug-in") foundSecondPlugin = true;
>         }
>-        ok(foundFirstPlugin, "Should have a plugin named 'Test Plug-in'");
>-        ok(foundSecondPlugin, "Should have a plugin named 'Second Test Plug-in'");
>+        ok(!foundFirstPlugin, "Should NOT have seen a hidden plugin named 'Test Plug-in'");
>+        ok(foundSecondPlugin, "Should have seen a non-hidden plugin named 'Second Test Plug-in'");
> 
>         var pluginElement = document.getElementById("plugin");
>         is(pluginElement.identifierToStringTest("foo"), "foo", "Should be able to call a function provided by the plugin");
> 
>+        //
>+        // Test hidden and non-hidden MIME types.
>+        //
>+        ok(navigator.mimeTypes["application/x-test"], "Should have a MIME type named 'application/x-test'");
>+        ok(navigator.mimeTypes["application/x-second-test"], "Should have a MIME type named 'application/x-second-test'");
>+
>+        var foundFirstMimeType = false;
>+        var foundSecondMimeType = false;
>+        for (var index in navigator.mimeTypes) {
>+          var mimeType = navigator.mimeTypes[index];
>+          if (mimeType.type == "application/x-test") foundFirstMimeType = true;
>+          if (mimeType.type == "application/x-second-test") foundSecondMimeType = true;
>+        }
>+        ok(!foundFirstMimeType, "Should NOT have seen a hidden MIME type named 'application/x-test'");
>+        ok(foundSecondMimeType, "Should have seen a non-hidden MIME type named 'application/x-second-test'");
>+
>         SimpleTest.finish();
>       }
>     </script>
> 
>     <object id="plugin" type="application/x-second-test" width=200 height=200></object>
>   </body>
> </html>
>diff --git a/dom/tests/mochitest/bugs/test_bug427744.html b/dom/tests/mochitest/bugs/test_bug427744.html
>--- a/dom/tests/mochitest/bugs/test_bug427744.html
>+++ b/dom/tests/mochitest/bugs/test_bug427744.html
>@@ -14,21 +14,20 @@ https://bugzilla.mozilla.org/show_bug.cg
> <div id="content" style="display: none">
>   
> </div>
> <pre id="test">
> <script class="testbody" type="text/javascript">
> 
> /** Test for Bug 427744 **/
> 
>-var found = false;
>-for (var i = 0; i < navigator.plugins.length; i++) {
>-  if (navigator.plugins[i].name == "Test Plug-in") {
>-    found = true;
>-    is(navigator.plugins[i].version, "1.0.0.0", "Should have seen the right version");
>-  }
>-}
>-ok(found, "Should have seen the test plugin");
>+var firstPlugin = navigator.plugins["Test Plug-in"];
>+ok(firstPlugin, "Should have seen the test plugin");
>+is(firstPlugin.version, "1.0.0.0", "Should have seen the right test plugin version");
>+
>+var secondPlugin = navigator.plugins["Second Test Plug-in"];
>+ok(secondPlugin, "Should have seen the second test plugin");
>+is(secondPlugin.version, "1.0.0.0", "Should have seen the right second test plugin version");
> 
> </script>
> </pre>
> </body>
> </html>
>diff --git a/layout/tools/reftest/reftest.js b/layout/tools/reftest/reftest.js
>--- a/layout/tools/reftest/reftest.js
>+++ b/layout/tools/reftest/reftest.js
>@@ -629,27 +629,19 @@ function BuildConditionSandbox(aURL) {
>     }
> 
>     // Set OSX to the Mac OS X version for Mac, and 0 otherwise.
>     var osxmatch = /Mac OS X (\d+.\d+)$/.exec(hh.oscpu);
>     sandbox.OSX = osxmatch ? parseFloat(osxmatch[1]) : 0;
> 
>     // see if we have the test plugin available,
>     // and set a sandox prop accordingly
>-    sandbox.haveTestPlugin = false;
>-
>     var navigator = gContainingWindow.navigator;
>-    for (var i = 0; i < navigator.mimeTypes.length; i++) {
>-        if (navigator.mimeTypes[i].type == "application/x-test" &&
>-            navigator.mimeTypes[i].enabledPlugin != null &&
>-            navigator.mimeTypes[i].enabledPlugin.name == "Test Plug-in") {
>-            sandbox.haveTestPlugin = true;
>-            break;
>-        }
>-    }
>+    var testPlugin = navigator.plugins["Test Plug-in"];
>+    sandbox.haveTestPlugin = !!testPlugin;
> 
>     // Set a flag on sandbox if the windows default theme is active
>     var box = gContainingWindow.document.createElement("box");
>     box.setAttribute("id", "_box_windowsDefaultTheme");
>     gContainingWindow.document.documentElement.appendChild(box);
>     sandbox.windowsDefaultTheme = (gContainingWindow.getComputedStyle(box, null).display == "none");
>     gContainingWindow.document.documentElement.removeChild(box);
>

Flags:

jaas: feedback+

Actions: View | Diff | Review

Attachments on bug 757726: 664380 | 674153 | 693268 | 693273 | 693793 | 820124 | 820126 | 820127 | 820130 | 820132 | 820133 | 825121 | 825122 | 825124 | 829927 | 829988 | 829992 | 831356 | 8421211