Clean up WebUIMojoTest.

content/browser/webui/web_ui_mojo_browsertest.cc

 // Copyright 2014 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 <limits>
 #include <utility>
 
-#include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "content/browser/webui/web_ui_controller_factory_registry.h"
 #include "content/public/browser/browser_context.h"
@@ skipping 12 matching lines @@
 #include "content/shell/browser/shell.h"
 #include "content/test/data/web_ui_test_mojo_bindings.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/interface_request.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "services/shell/public/cpp/interface_registry.h"
 
 namespace content {
 namespace {
 
+bool g_got_message = false;
+
 base::FilePath GetFilePathForJSResource(const std::string& path) {
   base::ThreadRestrictions::ScopedAllowIO allow_io_from_test_callbacks;
 
   std::string binding_path = "gen/" + path + ".js";
 #if defined(OS_WIN)
   base::ReplaceChars(binding_path, "//", "\\", &binding_path);
 #endif
   base::FilePath exe_dir;
   PathService::Get(base::DIR_EXE, &exe_dir);
   return exe_dir.AppendASCII(binding_path);
 }
 
-bool got_message = false;
-
 // The bindings for the page are generated from a .mojom file. This code looks
 // up the generated file from disk and returns it.
 bool GetResource(const std::string& id,
                  const WebUIDataSource::GotDataCallback& callback) {
   base::ThreadRestrictions::ScopedAllowIO allow_io_from_test_callbacks;
 
-  if (id.find(".mojom") != std::string::npos) {
-    std::string contents;
+  std::string contents;
+  if (base::EndsWith(id, ".mojom", base::CompareCase::SENSITIVE)) {
     CHECK(base::ReadFileToString(GetFilePathForJSResource(id), &contents))
         << id;
-    base::RefCountedString* ref_contents = new base::RefCountedString;
-    ref_contents->data() = contents;
-    callback.Run(ref_contents);
-    return true;
+  } else {
+    base::FilePath path;
+    CHECK(base::PathService::Get(content::DIR_TEST_DATA, &path));
+    path = path.AppendASCII(id.substr(0, id.find("?")));
+    CHECK(base::ReadFileToString(path, &contents)) << path.value();
   }
 
-  base::FilePath path;
-  CHECK(base::PathService::Get(content::DIR_TEST_DATA, &path));
-  path = path.AppendASCII(id.substr(0, id.find("?")));
-  std::string contents;
-  CHECK(base::ReadFileToString(path, &contents)) << path.value();
   base::RefCountedString* ref_contents = new base::RefCountedString;
   ref_contents->data() = contents;
   callback.Run(ref_contents);
   return true;
 }
 
 class BrowserTargetImpl : public mojom::BrowserTarget {
  public:
   BrowserTargetImpl(base::RunLoop* run_loop,
                     mojo::InterfaceRequest<mojom::BrowserTarget> request)
       : run_loop_(run_loop), binding_(this, std::move(request)) {}
 
   ~BrowserTargetImpl() override {}
 
   // mojom::BrowserTarget overrides:
   void Start(const StartCallback& closure) override {
     closure.Run();
   }
   void Stop() override {
-    got_message = true;
+    g_got_message = true;
     run_loop_->Quit();
   }
 
  protected:
-  base::RunLoop* run_loop_;
+  base::RunLoop* const run_loop_;
 
  private:
   mojo::Binding<mojom::BrowserTarget> binding_;
   DISALLOW_COPY_AND_ASSIGN(BrowserTargetImpl);
 };
 
 // WebUIController that sets up mojo bindings.
 class TestWebUIController : public WebUIController {
  public:
   TestWebUIController(WebUI* web_ui, base::RunLoop* run_loop)
       : WebUIController(web_ui), run_loop_(run_loop) {
-    content::WebUIDataSource* data_source =
-        WebUIDataSource::Create("mojo-web-ui");
+    WebUIDataSource* data_source = WebUIDataSource::Create("mojo-web-ui");
     data_source->SetRequestFilter(base::Bind(&GetResource));
-    content::WebUIDataSource::Add(web_ui->GetWebContents()->GetBrowserContext(),
-                                  data_source);
+    WebUIDataSource::Add(web_ui->GetWebContents()->GetBrowserContext(),
+                         data_source);
   }
 
  protected:
-  base::RunLoop* run_loop_;
+  base::RunLoop* const run_loop_;
   std::unique_ptr<BrowserTargetImpl> browser_target_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestWebUIController);
 };
 
 // TestWebUIController that additionally creates the ping test BrowserTarget
 // implementation at the right time.
 class PingTestWebUIController : public TestWebUIController {
  public:
-   PingTestWebUIController(WebUI* web_ui, base::RunLoop* run_loop)
-       : TestWebUIController(web_ui, run_loop) {
-   }
-   ~PingTestWebUIController() override {}
+  PingTestWebUIController(WebUI* web_ui, base::RunLoop* run_loop)
+      : TestWebUIController(web_ui, run_loop) {}
+  ~PingTestWebUIController() override {}
 
   // WebUIController overrides:
   void RenderViewCreated(RenderViewHost* render_view_host) override {
     render_view_host->GetMainFrame()->GetInterfaceRegistry()->AddInterface(
         base::Bind(&PingTestWebUIController::CreateHandler,
                    base::Unretained(this)));
   }
 
   void CreateHandler(mojo::InterfaceRequest<mojom::BrowserTarget> request) {
-    browser_target_.reset(new BrowserTargetImpl(run_loop_, std::move(request)));
+    browser_target_ =
+        base::MakeUnique<BrowserTargetImpl>(run_loop_, std::move(request));
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(PingTestWebUIController);
 };
 
 // WebUIControllerFactory that creates TestWebUIController.
 class TestWebUIControllerFactory : public WebUIControllerFactory {
  public:
-  TestWebUIControllerFactory() : run_loop_(NULL) {}
+  TestWebUIControllerFactory() : run_loop_(nullptr) {}
 
   void set_run_loop(base::RunLoop* run_loop) { run_loop_ = run_loop; }
 
   WebUIController* CreateWebUIControllerForURL(WebUI* web_ui,
                                                const GURL& url) const override {
     if (url.query() == "ping")
       return new PingTestWebUIController(web_ui, run_loop_);
     return new TestWebUIController(web_ui, run_loop_);
   }
   WebUI::TypeID GetWebUIType(BrowserContext* browser_context,
@@ skipping 46 matching lines @@
   return false;
 }
 
 // Loads a webui page that contains mojo bindings and verifies a message makes
 // it from the browser to the page and back.
 IN_PROC_BROWSER_TEST_F(WebUIMojoTest, EndToEndPing) {
   if (!IsGeneratedResourceAvailable(
           "content/test/data/web_ui_test_mojo_bindings.mojom"))
     return;
 
-  got_message = false;
+  g_got_message = false;
   ASSERT_TRUE(embedded_test_server()->Start());
   base::RunLoop run_loop;
   factory()->set_run_loop(&run_loop);
   GURL test_url("chrome://mojo-web-ui/web_ui_mojo.html?ping");
   NavigateToURL(shell(), test_url);
   // RunLoop is quit when message received from page.
   run_loop.Run();
-  EXPECT_TRUE(got_message);
+  EXPECT_TRUE(g_got_message);
 
   // Check that a second render frame in the same renderer process works
   // correctly.
   Shell* other_shell = CreateBrowser();
-  got_message = false;
+  g_got_message = false;
   base::RunLoop other_run_loop;
   factory()->set_run_loop(&other_run_loop);
   NavigateToURL(other_shell, test_url);
   // RunLoop is quit when message received from page.
   other_run_loop.Run();
-  EXPECT_TRUE(got_message);
+  EXPECT_TRUE(g_got_message);
   EXPECT_EQ(shell()->web_contents()->GetRenderProcessHost(),
             other_shell->web_contents()->GetRenderProcessHost());
 }
 
 }  // namespace
 }  // namespace content