path: root/chrome/browser/plugins/plugin_power_saver_browsertest.cc

// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <stdint.h>
#include <string>
#include <utility>

#include "base/command_line.h"
#include "base/stl_util.h"
#include "base/strings/string_piece.h"
#include "base/strings/stringprintf.h"
#include "build/build_config.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_window.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/test_switches.h"
#include "chrome/test/base/ui_test_utils.h"
#include "components/ui/zoom/zoom_controller.h"
#include "content/public/browser/readback_types.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_view_host.h"
#include "content/public/browser/render_widget_host.h"
#include "content/public/common/content_switches.h"
#include "content/public/test/browser_test_utils.h"
#include "content/public/test/ppapi_test_utils.h"
#include "net/test/embedded_test_server/embedded_test_server.h"
#include "net/test/embedded_test_server/http_request.h"
#include "net/test/embedded_test_server/http_response.h"
#include "ppapi/shared_impl/ppapi_switches.h"
#include "third_party/WebKit/public/web/WebInputEvent.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "ui/base/window_open_disposition.h"
#include "ui/gfx/codec/png_codec.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/screen.h"
#include "ui/gfx/switches.h"

namespace {

// Use fixed browser dimensions for pixel tests.
const int kBrowserWidth = 600;
const int kBrowserHeight = 700;

// Compare only a portion of the snapshots, as different platforms will
// capture different sized snapshots (due to differences in browser chrome).
const int kComparisonWidth = 500;
const int kComparisonHeight = 600;

// Different platforms have slightly different pixel output, due to different
// graphics implementations. Slightly different pixels (in BGR space) are still
// counted as a matching pixel by this simple manhattan distance threshold.
const int kPixelManhattanDistanceTolerance = 20;

std::string RunTestScript(base::StringPiece test_script,
                          content::WebContents* contents,
                          const std::string& element_id) {
  std::string script = base::StringPrintf(
      "var plugin = window.document.getElementById('%s');"
      "if (plugin === undefined ||"
      "    (plugin.nodeName !== 'OBJECT' && plugin.nodeName !== 'EMBED')) {"
      "  window.domAutomationController.send('error');"
      "} else {"
      "  %s"
      "}",
      element_id.c_str(), test_script.data());
  std::string result;
  EXPECT_TRUE(
      content::ExecuteScriptAndExtractString(contents, script, &result));
  return result;
}

// This also tests that we have JavaScript access to the underlying plugin.
bool PluginLoaded(content::WebContents* contents,
                  const std::string& element_id) {
  std::string result = RunTestScript(
      "if (plugin.postMessage === undefined) {"
      "  window.domAutomationController.send('poster_only');"
      "} else {"
      "  window.domAutomationController.send('plugin_loaded');"
      "}",
      contents, element_id);
  EXPECT_NE("error", result);
  return result == "plugin_loaded";
}

// Blocks until the placeholder is ready.
void WaitForPlaceholderReady(content::WebContents* contents,
                             const std::string& element_id) {
  std::string result = RunTestScript(
      "function handleEvent(event) {"
      "  if (event.data === 'placeholderReady') {"
      "    window.domAutomationController.send('ready');"
      "    plugin.removeEventListener('message', handleEvent);"
      "  }"
      "}"
      "plugin.addEventListener('message', handleEvent);"
      "if (plugin.hasAttribute('placeholderReady')) {"
      "  window.domAutomationController.send('ready');"
      "  plugin.removeEventListener('message', handleEvent);"
      "}",
      contents, element_id);
  ASSERT_EQ("ready", result);
}

// Also waits for the placeholder UI overlay to finish loading.
void VerifyPluginIsThrottled(content::WebContents* contents,
                             const std::string& element_id) {
  std::string result = RunTestScript(
      "function handleEvent(event) {"
      "  if (event.data.isPeripheral && event.data.isThrottled && "
      "      event.data.isHiddenForPlaceholder) {"
      "    window.domAutomationController.send('throttled');"
      "    plugin.removeEventListener('message', handleEvent);"
      "  }"
      "}"
      "plugin.addEventListener('message', handleEvent);"
      "if (plugin.postMessage !== undefined) {"
      "  plugin.postMessage('getPowerSaverStatus');"
      "}",
      contents, element_id);
  EXPECT_EQ("throttled", result);

  // Page should continue to have JavaScript access to all throttled plugins.
  EXPECT_TRUE(PluginLoaded(contents, element_id));

  WaitForPlaceholderReady(contents, element_id);
}

void VerifyPluginMarkedEssential(content::WebContents* contents,
                                 const std::string& element_id) {
  std::string result = RunTestScript(
      "function handleEvent(event) {"
      "  if (event.data.isPeripheral === false) {"
      "    window.domAutomationController.send('essential');"
      "    plugin.removeEventListener('message', handleEvent);"
      "  }"
      "}"
      "plugin.addEventListener('message', handleEvent);"
      "if (plugin.postMessage !== undefined) {"
      "  plugin.postMessage('getPowerSaverStatus');"
      "}",
      contents, element_id);
  EXPECT_EQ("essential", result);
  EXPECT_TRUE(PluginLoaded(contents, element_id));
}

scoped_ptr<net::test_server::HttpResponse> RespondWithHTML(
    const std::string& html,
    const net::test_server::HttpRequest& request) {
  scoped_ptr<net::test_server::BasicHttpResponse> response(
      new net::test_server::BasicHttpResponse());
  response->set_content_type("text/html");
  response->set_content(html);
  return std::move(response);
}

void VerifyVisualStateUpdated(const base::Closure& done_cb,
                              bool visual_state_updated) {
  ASSERT_TRUE(visual_state_updated);
  done_cb.Run();
}

bool SnapshotMatches(const base::FilePath& reference, const SkBitmap& bitmap) {
  if (bitmap.width() < kComparisonWidth ||
      bitmap.height() < kComparisonHeight) {
    return false;
  }

  std::string reference_data;
  if (!base::ReadFileToString(reference, &reference_data))
    return false;

  int w = 0;
  int h = 0;
  std::vector<unsigned char> decoded;
  if (!gfx::PNGCodec::Decode(
          reinterpret_cast<unsigned char*>(string_as_array(&reference_data)),
          reference_data.size(), gfx::PNGCodec::FORMAT_BGRA, &decoded, &w,
          &h)) {
    return false;
  }

  if (w < kComparisonWidth || h < kComparisonHeight)
    return false;

  int32_t* ref_pixels = reinterpret_cast<int32_t*>(decoded.data());
  SkAutoLockPixels lock_image(bitmap);
  int32_t* pixels = static_cast<int32_t*>(bitmap.getPixels());

  int stride = bitmap.rowBytes();
  for (int y = 0; y < kComparisonHeight; ++y) {
    for (int x = 0; x < kComparisonWidth; ++x) {
      int32_t pixel = pixels[y * stride / sizeof(int32_t) + x];
      int pixel_b = pixel & 0xFF;
      int pixel_g = (pixel >> 8) & 0xFF;
      int pixel_r = (pixel >> 16) & 0xFF;

      int32_t ref_pixel = ref_pixels[y * w + x];
      int ref_pixel_b = ref_pixel & 0xFF;
      int ref_pixel_g = (ref_pixel >> 8) & 0xFF;
      int ref_pixel_r = (ref_pixel >> 16) & 0xFF;

      int manhattan_distance = abs(pixel_b - ref_pixel_b) +
                               abs(pixel_g - ref_pixel_g) +
                               abs(pixel_r - ref_pixel_r);

      if (manhattan_distance > kPixelManhattanDistanceTolerance) {
        ADD_FAILURE() << "Pixel test failed on (" << x << ", " << y << "). " <<
            "Pixel manhattan distance: " << manhattan_distance << ".";
        return false;
      }
    }
  }

  return true;
}

// |snapshot_matches| is set to true if the snapshot matches the reference and
// the test passes. Otherwise, set to false.
void CompareSnapshotToReference(const base::FilePath& reference,
                                bool* snapshot_matches,
                                const base::Closure& done_cb,
                                const SkBitmap& bitmap,
                                content::ReadbackResponse response) {
  DCHECK(snapshot_matches);
  ASSERT_EQ(content::READBACK_SUCCESS, response);

  *snapshot_matches = SnapshotMatches(reference, bitmap);

  // When rebaselining the pixel test, the test will fail, and we will
  // overwrite the reference file. On the next try through, the test will then
  // pass, since we just overwrote the reference file. A bit wonky.
  if (!(*snapshot_matches) &&
      base::CommandLine::ForCurrentProcess()->HasSwitch(
          switches::kRebaselinePixelTests)) {
    SkBitmap clipped_bitmap;
    bitmap.extractSubset(&clipped_bitmap,
                         SkIRect::MakeWH(kComparisonWidth, kComparisonHeight));
    std::vector<unsigned char> png_data;
    ASSERT_TRUE(
        gfx::PNGCodec::EncodeBGRASkBitmap(clipped_bitmap, false, &png_data));
    ASSERT_EQ(static_cast<int>(png_data.size()),
              base::WriteFile(reference,
                              reinterpret_cast<const char*>(png_data.data()),
                              png_data.size()));
  }

  done_cb.Run();
}

}  // namespace

class PluginPowerSaverBrowserTest : public InProcessBrowserTest {
 public:
  void SetUp() override {
    if (PixelTestsEnabled())
      EnablePixelOutput();

    InProcessBrowserTest::SetUp();
  }

  void SetUpOnMainThread() override {
    InProcessBrowserTest::SetUpOnMainThread();
    ASSERT_TRUE(embedded_test_server()->Start());

    embedded_test_server()->ServeFilesFromDirectory(
        ui_test_utils::GetTestFilePath(
            base::FilePath(FILE_PATH_LITERAL("plugin_power_saver")),
            base::FilePath()));
  }

  void SetUpCommandLine(base::CommandLine* command_line) override {
    command_line->AppendSwitch(switches::kEnablePepperTesting);
    command_line->AppendSwitch(switches::kEnablePluginPlaceholderTesting);
    command_line->AppendSwitchASCII(
        switches::kOverridePluginPowerSaverForTesting, "ignore-list");

    ASSERT_TRUE(ppapi::RegisterPowerSaverTestPlugin(command_line));

    // Allows us to use the same reference image on HiDPI/Retina displays.
    command_line->AppendSwitchASCII(switches::kForceDeviceScaleFactor, "1");

#if !defined(OS_CHROMEOS)
    // These pixel tests are flaky on MSan bots with hardware rendering.
    // However, ChromeOS does not support software compositing.
    command_line->AppendSwitch(switches::kDisableGpu);
#endif
  }

 protected:
  void LoadHTML(const std::string& html) {
    if (PixelTestsEnabled()) {
      gfx::Rect bounds(gfx::Rect(0, 0, kBrowserWidth, kBrowserHeight));
      gfx::Rect screen_bounds =
          gfx::Screen::GetScreen()->GetPrimaryDisplay().bounds();
      ASSERT_GT(screen_bounds.width(), kBrowserWidth);
      ASSERT_GT(screen_bounds.height(), kBrowserHeight);
      browser()->window()->SetBounds(bounds);
    }

    ASSERT_TRUE(embedded_test_server()->Started());
    embedded_test_server()->RegisterRequestHandler(
        base::Bind(&RespondWithHTML, html));
    ui_test_utils::NavigateToURL(browser(), embedded_test_server()->base_url());
    EXPECT_TRUE(content::WaitForRenderFrameReady(
        GetActiveWebContents()->GetMainFrame()));
  }

  content::WebContents* GetActiveWebContents() {
    return browser()->tab_strip_model()->GetActiveWebContents();
  }

  // This sends a simulated click at |point| and waits for test plugin to send
  // a status message indicating that it is essential. The test plugin sends a
  // status message during:
  //  - Plugin creation, to handle a plugin freshly created from a poster.
  //  - Peripheral status change.
  //  - In response to the explicit 'getPowerSaverStatus' request, in case the
  //    test has missed the above two events.
  void SimulateClickAndAwaitMarkedEssential(const std::string& element_id,
                                            const gfx::Point& point) {
    WaitForPlaceholderReady(GetActiveWebContents(), element_id);
    content::SimulateMouseClickAt(GetActiveWebContents(), 0 /* modifiers */,
                                  blink::WebMouseEvent::ButtonLeft, point);

    VerifyPluginMarkedEssential(GetActiveWebContents(), element_id);
  }

  // |element_id| must be an element on the foreground tab.
  void VerifyPluginIsPosterOnly(const std::string& element_id) {
    EXPECT_FALSE(PluginLoaded(GetActiveWebContents(), element_id));
    WaitForPlaceholderReady(GetActiveWebContents(), element_id);
  }

  bool VerifySnapshot(const base::FilePath::StringType& expected_filename) {
    if (!PixelTestsEnabled())
      return true;

    base::FilePath reference = ui_test_utils::GetTestFilePath(
        base::FilePath(FILE_PATH_LITERAL("plugin_power_saver")),
        base::FilePath(expected_filename));

    GetActiveWebContents()->GetMainFrame()->InsertVisualStateCallback(
        base::Bind(&VerifyVisualStateUpdated,
                   base::MessageLoop::QuitWhenIdleClosure()));
    content::RunMessageLoop();

    content::RenderWidgetHost* rwh =
        GetActiveWebContents()->GetRenderViewHost()->GetWidget();

    if (!rwh->CanCopyFromBackingStore()) {
      ADD_FAILURE() << "Could not copy from backing store.";
      return false;
    }

    bool snapshot_matches = false;
    rwh->CopyFromBackingStore(
        gfx::Rect(), gfx::Size(),
        base::Bind(&CompareSnapshotToReference, reference, &snapshot_matches,
                   base::MessageLoop::QuitWhenIdleClosure()),
        kN32_SkColorType);

    content::RunMessageLoop();

    return snapshot_matches;
  }

  // TODO(tommycli): Remove this once all flakiness resolved.
  bool PixelTestsEnabled() {
#if defined(OS_WIN) || defined(ADDRESS_SANITIZER)
    // Flaky on Windows and Asan bots. See crbug.com/549285.
    return false;
#elif defined(OS_CHROMEOS) && defined(MEMORY_SANITIZER)
    // Because we cannot use hardware OpenGL under MSan, but also cannot use
    // software rendering under ChromeOS, we skip this portion of the test.
    // See crbug.com/512140
    return false;
#else
    return true;
#endif
  }
};

IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest, SmallSameOrigin) {
  LoadHTML(
      "<object id='plugin' data='fake.swf' "
      "    type='application/x-ppapi-tests' width='400' height='100'>"
      "</object>"
      "<object id='plugin_poster' data='fake.swf' poster='click_me.png' "
      "    type='application/x-ppapi-tests' width='400' height='100'>"
      "</object>");
  VerifyPluginMarkedEssential(GetActiveWebContents(), "plugin");
  VerifyPluginMarkedEssential(GetActiveWebContents(), "plugin_poster");
}

IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest, SmallCrossOrigin) {
  LoadHTML(
      "<object id='plugin' data='http://otherorigin.com/fake.swf' "
      "    type='application/x-ppapi-tests' width='400' height='100'>"
      "</object>"
      "<br>"
      "<object id='plugin_poster' data='http://otherorigin.com/fake.swf' "
      "    type='application/x-ppapi-tests' width='400' height='100' "
      "    poster='click_me.png'>"
      "</object>");

  VerifyPluginIsThrottled(GetActiveWebContents(), "plugin");
  VerifyPluginIsPosterOnly("plugin_poster");

  EXPECT_TRUE(
      VerifySnapshot(FILE_PATH_LITERAL("small_cross_origin_expected.png")));

  SimulateClickAndAwaitMarkedEssential("plugin", gfx::Point(50, 50));
  SimulateClickAndAwaitMarkedEssential("plugin_poster", gfx::Point(50, 150));
}

IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest, LargeCrossOrigin) {
  LoadHTML(
      "<object id='large' data='http://otherorigin.com/fake.swf' "
      "    type='application/x-ppapi-tests' width='400' height='500'>"
      "</object>"
      "<object id='medium_16_9' data='http://otherorigin.com/fake.swf' "
      "    type='application/x-ppapi-tests' width='480' height='270'>"
      "</object>");
  VerifyPluginMarkedEssential(GetActiveWebContents(), "large");
  VerifyPluginMarkedEssential(GetActiveWebContents(), "medium_16_9");
}

IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest, SmallerThanPlayIcon) {
  LoadHTML(
      "<object id='plugin_16' type='application/x-ppapi-tests' "
      "    width='16' height='16'></object>"
      "<object id='plugin_32' type='application/x-ppapi-tests' "
      "    width='32' height='32'></object>"
      "<object id='plugin_16_64' type='application/x-ppapi-tests' "
      "    width='16' height='64'></object>"
      "<object id='plugin_64_16' type='application/x-ppapi-tests' "
      "    width='64' height='16'></object>");

  VerifyPluginIsThrottled(GetActiveWebContents(), "plugin_16");
  VerifyPluginIsThrottled(GetActiveWebContents(), "plugin_32");
  VerifyPluginIsThrottled(GetActiveWebContents(), "plugin_16_64");
  VerifyPluginIsThrottled(GetActiveWebContents(), "plugin_64_16");

  EXPECT_TRUE(
      VerifySnapshot(FILE_PATH_LITERAL("smaller_than_play_icon_expected.png")));
}

IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest, PosterTests) {
  // This test simultaneously verifies the varied supported poster syntaxes,
  // as well as verifies that the poster is rendered correctly with various
  // mismatched aspect ratios and sizes, following the same rules as VIDEO.
  LoadHTML(
      "<object id='plugin_src' type='application/x-ppapi-tests' "
      "    width='100' height='100' poster='click_me.png'></object>"
      "<object id='plugin_srcset' type='application/x-ppapi-tests' "
      "    width='100' height='100' "
      "    poster='click_me.png 1x, click_me.png 2x'></object>"
      "<br>"

      "<object id='plugin_poster_param' type='application/x-ppapi-tests' "
      "    width='100' height='100'>"
      "  <param name='poster' value='click_me.png 1x, click_me.png 2x'>"
      "</object>"
      "<embed id='plugin_embed_src' type='application/x-ppapi-tests' "
      "    width='100' height='100' poster='click_me.png'></embed>"
      "<embed id='plugin_embed_srcset' type='application/x-ppapi-tests' "
      "    width='100' height='100'"
      "    poster='click_me.png 1x, click_me.png 2x'></embed>"
      "<br>"

      "<object id='poster_missing' type='application/x-ppapi-tests' "
      "    width='100' height='100' poster='missing.png'></object>"
      "<object id='poster_too_small' type='application/x-ppapi-tests' "
      "    width='100' height='50' poster='click_me.png'></object>"
      "<object id='poster_too_big' type='application/x-ppapi-tests' "
      "    width='100' height='150' poster='click_me.png'></object>"
      "<br>"

      "<object id='poster_16' type='application/x-ppapi-tests' "
      "    width='16' height='16' poster='click_me.png'></object>"
      "<object id='poster_32' type='application/x-ppapi-tests' "
      "    width='32' height='32' poster='click_me.png'></object>"
      "<object id='poster_16_64' type='application/x-ppapi-tests' "
      "    width='16' height='64' poster='click_me.png'></object>"
      "<object id='poster_64_16' type='application/x-ppapi-tests' "
      "    width='64' height='16' poster='click_me.png'></object>"
      "<br>"

      "<div id='container' "
      "    style='width: 400px; height: 100px; overflow: hidden;'>"
      "  <object id='poster_obscured' data='http://otherorigin.com/fake.swf' "
      "      type='application/x-ppapi-tests' width='400' height='500' "
      "      poster='click_me.png'>"
      "  </object>"
      "</div>");

  VerifyPluginIsPosterOnly("plugin_src");
  VerifyPluginIsPosterOnly("plugin_srcset");

  VerifyPluginIsPosterOnly("plugin_poster_param");
  VerifyPluginIsPosterOnly("plugin_embed_src");
  VerifyPluginIsPosterOnly("plugin_embed_srcset");

  VerifyPluginIsPosterOnly("poster_missing");
  VerifyPluginIsPosterOnly("poster_too_small");
  VerifyPluginIsPosterOnly("poster_too_big");

  VerifyPluginIsPosterOnly("poster_16");
  VerifyPluginIsPosterOnly("poster_32");
  VerifyPluginIsPosterOnly("poster_16_64");
  VerifyPluginIsPosterOnly("poster_64_16");

  VerifyPluginIsPosterOnly("poster_obscured");

  EXPECT_TRUE(VerifySnapshot(FILE_PATH_LITERAL("poster_tests_expected.png")));
}

IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest, LargePostersNotThrottled) {
  // This test verifies that small posters are throttled, large posters are not,
  // and that large posters can whitelist origins for other plugins.
  LoadHTML(
      "<object id='poster_small' data='http://a.com/fake.swf' "
      "    type='application/x-ppapi-tests' width='50' height='50' "
      "    poster='click_me.png'></object>"
      "<object id='poster_whitelisted_origin' data='http://b.com/fake.swf' "
      "    type='application/x-ppapi-tests' width='50' height='50' "
      "    poster='click_me.png'></object>"
      "<object id='plugin_whitelisted_origin' data='http://b.com/fake.swf' "
      "    type='application/x-ppapi-tests' width='50' height='50'></object>"
      "<br>"
      "<object id='poster_large' data='http://b.com/fake.swf' "
      "    type='application/x-ppapi-tests' width='400' height='300' "
      "    poster='click_me.png'></object>");

  VerifyPluginIsPosterOnly("poster_small");
  VerifyPluginMarkedEssential(GetActiveWebContents(),
                              "poster_whitelisted_origin");
  VerifyPluginMarkedEssential(GetActiveWebContents(),
                              "plugin_whitelisted_origin");
  VerifyPluginMarkedEssential(GetActiveWebContents(), "poster_large");
}

IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest,
                       PluginMarkedEssentialAfterPosterClicked) {
  LoadHTML(
      "<object id='plugin' type='application/x-ppapi-tests' "
      "    width='400' height='100' poster='snapshot1x.png'></object>");
  VerifyPluginIsPosterOnly("plugin");

  SimulateClickAndAwaitMarkedEssential("plugin", gfx::Point(50, 50));
}

// Flaky on ASAN bots: crbug.com/560765.
#if defined(ADDRESS_SANITIZER)
#define MAYBE_OriginWhitelisting DISABLED_OriginWhitelisting
#else
#define MAYBE_OriginWhitelisting OriginWhitelisting
#endif
IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest, MAYBE_OriginWhitelisting) {
  LoadHTML(
      "<object id='plugin_small' data='http://a.com/fake1.swf' "
      "    type='application/x-ppapi-tests' width='100' height='100'></object>"
      "<object id='plugin_small_poster' data='http://a.com/fake1.swf' "
      "    type='application/x-ppapi-tests' width='100' height='100' "
      "    poster='click_me.png'></object>"
      "<object id='plugin_large' data='http://a.com/fake2.swf' "
      "    type='application/x-ppapi-tests' width='400' height='500'>"
      "</object>");
  VerifyPluginMarkedEssential(GetActiveWebContents(), "plugin_small");
  VerifyPluginMarkedEssential(GetActiveWebContents(), "plugin_small_poster");
  VerifyPluginMarkedEssential(GetActiveWebContents(), "plugin_large");
}

IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest, LargeCrossOriginObscured) {
  LoadHTML(
      "<div id='container' "
      "    style='width: 100px; height: 400px; overflow: hidden;'>"
      "  <object id='plugin' data='http://otherorigin.com/fake.swf' "
      "      type='application/x-ppapi-tests' width='400' height='500' "
      "      style='float: right;'>"
      "  </object>"
      "</div>");
  VerifyPluginIsThrottled(GetActiveWebContents(), "plugin");
  EXPECT_TRUE(VerifySnapshot(
      FILE_PATH_LITERAL("large_cross_origin_obscured_expected.png")));

  // Test that's unthrottled if it is unobscured.
  std::string script =
      "var container = window.document.getElementById('container');"
      "container.setAttribute('style', 'width: 400px; height: 400px;');";
  ASSERT_TRUE(content::ExecuteScript(GetActiveWebContents(), script));
  VerifyPluginMarkedEssential(GetActiveWebContents(), "plugin");
}

IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest, ExpandingSmallPlugin) {
  LoadHTML(
      "<object id='plugin' data='http://otherorigin.com/fake.swf' "
      "    type='application/x-ppapi-tests' width='400' height='80'></object>");
  VerifyPluginIsThrottled(GetActiveWebContents(), "plugin");

  std::string script = "window.document.getElementById('plugin').height = 400;";
  ASSERT_TRUE(content::ExecuteScript(GetActiveWebContents(), script));
  VerifyPluginMarkedEssential(GetActiveWebContents(), "plugin");
}

IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest, BackgroundTabPlugins) {
  std::string html =
      "<object id='same_origin' data='fake.swf' "
      "    type='application/x-ppapi-tests'></object>"
      "<object id='small_cross_origin' data='http://otherorigin.com/fake1.swf' "
      "    type='application/x-ppapi-tests' width='400' height='100'></object>";
  embedded_test_server()->RegisterRequestHandler(
      base::Bind(&RespondWithHTML, html));
  ui_test_utils::NavigateToURLWithDisposition(
      browser(), embedded_test_server()->base_url(), NEW_BACKGROUND_TAB,
      ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION);

  ASSERT_EQ(2, browser()->tab_strip_model()->count());
  content::WebContents* background_contents =
      browser()->tab_strip_model()->GetWebContentsAt(1);
  EXPECT_TRUE(
      content::WaitForRenderFrameReady(background_contents->GetMainFrame()));

  EXPECT_FALSE(PluginLoaded(background_contents, "same_origin"));
  EXPECT_FALSE(PluginLoaded(background_contents, "small_cross_origin"));

  browser()->tab_strip_model()->SelectNextTab();
  EXPECT_EQ(background_contents, GetActiveWebContents());

  VerifyPluginMarkedEssential(background_contents, "same_origin");
  VerifyPluginIsThrottled(background_contents, "small_cross_origin");
}

IN_PROC_BROWSER_TEST_F(PluginPowerSaverBrowserTest, ZoomIndependent) {
  ui_zoom::ZoomController::FromWebContents(GetActiveWebContents())
      ->SetZoomLevel(4.0);
  LoadHTML(
      "<object id='plugin' data='http://otherorigin.com/fake.swf' "
      "    type='application/x-ppapi-tests' width='400' height='200'>"
      "</object>");
  VerifyPluginIsThrottled(GetActiveWebContents(), "plugin");
}