Added browser tests to test the BudgetAPI. Also added BudgetAPI to ExperimentalWebPlatformFeatures.

chrome/browser/budget_service/budget_manager_browsertest.cc

Index: chrome/browser/budget_service/budget_manager_browsertest.cc
diff --git a/chrome/browser/budget_service/budget_manager_browsertest.cc b/chrome/browser/budget_service/budget_manager_browsertest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..57b8c3de1b85188ffaed16adaa373873d9c44928
--- /dev/null
+++ b/chrome/browser/budget_service/budget_manager_browsertest.cc
@@ -0,0 +1,163 @@
+// Copyright 2016 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 "base/bind_helpers.h"
+#include "base/command_line.h"
+#include "base/run_loop.h"
+#include "chrome/browser/budget_service/budget_manager.h"
+#include "chrome/browser/budget_service/budget_manager_factory.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "chrome/test/base/ui_test_utils.h"
+#include "content/public/browser/browser_context.h"
+#include "content/public/browser/web_contents.h"
+#include "content/public/common/content_switches.h"
+#include "content/public/test/browser_test_utils.h"
+#include "net/test/embedded_test_server/embedded_test_server.h"
+#include "third_party/WebKit/public/platform/modules/budget_service/budget_service.mojom.h"
+#include "url/origin.h"
+
+namespace {
+
+const std::string kTestURL = "/budget_service/test.html";

[Peter Beverloo, 2016/09/28 13:04:27]

This is a static initializer, which are bad. Instead, use a const char[]:

const char kTestURL[] = "...";


For more background -

Basically, the memory backing an std::string lives on the heap as opposed to the
stack. That means it has to be allocated at some point.

For regular code, i.e. functions and methods and members (through constructors),
this happens either when the code is being executed, or when the class is being
allocated.

For global code, i.e. this, this happens when the program starts. (Before the
main() function, even.) That means that a simple statement like this will affect
start-up performance of the entire browser, or, in this case, test suite.

Early in on Chrome for Android development, the sum of static initializers
actually penalized start up performance by ~350ms. Since then we banned them.

[harkness, 2016/09/28 14:34:19]

Good catch, I was just being careless when I moved it up here from inside the
class.

+
+class BudgetManagerBrowserTest : public InProcessBrowserTest {
+ public:
+  BudgetManagerBrowserTest() = default;
+  ~BudgetManagerBrowserTest() override = default;
+
+  // InProcessBrowserTest:
+  void SetUp() override {
+    https_server_.reset(
+        new net::EmbeddedTestServer(net::EmbeddedTestServer::TYPE_HTTPS));
+    https_server_->ServeFilesFromSourceDirectory("chrome/test/data");
+    ASSERT_TRUE(https_server_->Start());
+
+    InProcessBrowserTest::SetUp();
+  }
+
+  // InProcessBrowserTest:
+  void SetUpOnMainThread() override {
+    LoadTestPage();
+    InProcessBrowserTest::SetUpOnMainThread();
+    budget_manager_ = BudgetManagerFactory::GetForProfile(browser()->profile());
+  }
+
+  // InProcessBrowserTest:
+  void SetUpCommandLine(base::CommandLine* command_line) override {
+    // TODO(harkness): Remove switch once Budget API ships. (crbug.com/617971)
+    command_line->AppendSwitch(
+        switches::kEnableExperimentalWebPlatformFeatures);
+    InProcessBrowserTest::SetUpCommandLine(command_line);
+  }
+
+  bool RunScript(const std::string& script, std::string* result) {
+    content::WebContents* web_contents =
+        browser()->tab_strip_model()->GetActiveWebContents();
+    return content::ExecuteScriptAndExtractString(web_contents->GetMainFrame(),
+                                                  script, result);
+  }
+
+  void LoadTestPage() {
+    ui_test_utils::NavigateToURL(browser(), https_server_->GetURL(kTestURL));
+  }
+
+  void DidConsume(base::Closure run_loop_closure, bool success) {
+    success_ = success;
+    run_loop_closure.Run();
+  }
+
+  void ConsumeReservation() {
+    base::RunLoop run_loop;
+    budget_manager()->Consume(
+        url::Origin(https_server_->GetURL(kTestURL)),
+        blink::mojom::BudgetOperationType::SILENT_PUSH,
+        base::Bind(&BudgetManagerBrowserTest::DidConsume,
+                   base::Unretained(this), run_loop.QuitClosure()));
+    run_loop.Run();
+  }
+
+  BudgetManager* budget_manager() const { return budget_manager_; }
+  bool success() const { return success_; }
+
+ protected:

[Peter Beverloo, 2016/09/28 13:04:27]

If the members are protected, the tests should access them directly (without the
getters on line 83/84). If the members are private, the tests should use getters
instead.

Production code doesn't allow protected member variables. We allow both for test
suites. Which one you pick is up to you.

[harkness, 2016/09/28 14:34:19]

Moved to private.

+  std::unique_ptr<net::EmbeddedTestServer> https_server_;
+  // Lifetime of the BudgetManager is tied to the profile of the test.
+  BudgetManager* budget_manager_;
+  bool success_ = false;
+};
+
+IN_PROC_BROWSER_TEST_F(BudgetManagerBrowserTest, BudgetInDocument) {
+  std::string script_result;
+
+  // The page will have been loaded once, which gives a budget of 3.
+  ASSERT_TRUE(RunScript("documentGetBudget()", &script_result));
+  ASSERT_EQ("ok - budget returned value of 3", script_result);
+
+  ASSERT_TRUE(RunScript("documentReserveBudget()", &script_result));
+  ASSERT_EQ("ok - reserved budget", script_result);
+
+  // After reserving budget, the new budget should be at 1.
+  ASSERT_TRUE(RunScript("documentGetBudget()", &script_result));
+  ASSERT_EQ("ok - budget returned value of 1", script_result);
+
+  // A second reserve should fail because there is not enough budget.
+  ASSERT_TRUE(RunScript("documentReserveBudget()", &script_result));
+  ASSERT_EQ("failed - not able to reserve budget", script_result);
+
+  // Consume should succeed because there is an existing reservation.
+  ConsumeReservation();
+  ASSERT_TRUE(success());
+
+  // Second consume should fail because the reservation is consumed.
+  ConsumeReservation();
+  ASSERT_FALSE(success());
+}
+
+IN_PROC_BROWSER_TEST_F(BudgetManagerBrowserTest, BudgetInWorker) {
+  std::string script_result;
+
+  ASSERT_TRUE(RunScript("registerServiceWorker()", &script_result));
+  ASSERT_EQ("ok - service worker registered", script_result);
+
+  LoadTestPage();  // Reload to become controlled.
+
+  ASSERT_TRUE(RunScript("isControlled()", &script_result));
+  ASSERT_EQ("true - is controlled", script_result);
+
+  // The page will have been loaded twice and a service worker was registered,
+  // which gives a budget of 4.5.
+  ASSERT_TRUE(RunScript("workerGetBudget()", &script_result));
+  ASSERT_EQ("ok - budget returned value of 4.5", script_result);
+
+  // With a budget of 4.5, two reservations should succeed.
+  ASSERT_TRUE(RunScript("workerReserveBudget()", &script_result));
+  ASSERT_EQ("ok - reserved budget", script_result);
+
+  ASSERT_TRUE(RunScript("workerReserveBudget()", &script_result));
+  ASSERT_EQ("ok - reserved budget", script_result);
+
+  // After reserving budget, the new budget should be at 0.5.
+  ASSERT_TRUE(RunScript("workerGetBudget()", &script_result));
+  ASSERT_EQ("ok - budget returned value of 0.5", script_result);
+
+  // A second reserve should fail because there is not enough budget.
+  ASSERT_TRUE(RunScript("workerReserveBudget()", &script_result));
+  ASSERT_EQ("failed - not able to reserve budget", script_result);
+
+  // Two consumes should succeed because there are existing reservations.
+  ConsumeReservation();
+  ASSERT_TRUE(success());
+
+  ConsumeReservation();
+  ASSERT_TRUE(success());
+
+  // One more consume should fail, because all reservations are consumed.
+  ConsumeReservation();
+  ASSERT_FALSE(success());
+}
+
+}  // namespace