Resize DevTools target frames.

content/browser/devtools/protocol/devtools_protocol_browsertest.cc

 // Copyright 2013 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 <stddef.h>
 #include <utility>
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/javascript_dialog_manager.h"
 #include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/content_browser_test.h"
 #include "content/public/test/content_browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "content/shell/browser/shell.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/gfx/codec/png_codec.h"
 
+#define EXPECT_SIZE_EQ(expected, actual)               \

[alex clarke (OOO till 29th), 2016/08/10 12:39:48]

Consider doing this instead:

std::ostream& operator<<(std::ostream& os, gfx::Size s) {
  return os << s.ToString();
}

Maybe that could live in ui/gfx/geometry/size.h?

[Eric Seckler, 2016/08/10 12:57:06]

I like this better, since it avoids the conversion to string (and, in my
opinion, produces nicer error messages). This helper is copied in various places
around the code base at the moment. I agree, it should probably live somewhere
where it can be reused. The most "central" place it currently lives is here in
cc: cc/test/geometry_test_utils.h. Does it make sense to move it to ui/gfx, or
can we depend on this file in cc?

+  do {                                                 \
+    EXPECT_EQ((expected).width(), (actual).width());   \
+    EXPECT_EQ((expected).height(), (actual).height()); \
+  } while (false)
+
 using testing::ElementsAre;
 
 namespace content {
 
 namespace {
 
 const char kIdParam[] = "id";
 const char kMethodParam[] = "method";
 const char kParamsParam[] = "params";
 
@@ skipping 632 matching lines @@
   TestJavaScriptDialogManager dialog_manager;
   shell()->web_contents()->SetDelegate(&dialog_manager);
   SendCommand("Page.enable", nullptr, true);
   std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetString("expression", "alert('alert')");
   SendCommand("Runtime.evaluate", std::move(params), false);
   WaitForNotification("Page.javascriptDialogOpening");
   dialog_manager.Handle();
 }
 
-IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, BrowserCreateTarget) {
+IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, BrowserCreateAndCloseTarget) {
   NavigateToURLBlockUntilNavigationsComplete(shell(), GURL("about:blank"), 1);
   Attach();
   EXPECT_EQ(1u, shell()->windows().size());
+
+  // Create target with default size.
   std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetString("url", "about:blank");
   SendCommand("Browser.createTarget", std::move(params), true);
-  EXPECT_EQ(2u, shell()->windows().size());
+  std::string target_id1;
+  EXPECT_TRUE(result_->GetString("targetId", &target_id1));
+  gfx::Size expected_size = (shell()->web_contents())
+                                ->GetRenderWidgetHostView()
+                                ->GetViewBounds()
+                                .size();
+  gfx::Size actual_size = (shell()->windows().back()->web_contents())
+                              ->GetRenderWidgetHostView()
+                              ->GetViewBounds()
+                              .size();
+  EXPECT_SIZE_EQ(expected_size, actual_size);
+
+  // Create target with custom frame size.
+  params.reset(new base::DictionaryValue());
+  params->SetString("url", "about:blank");
+  params->SetInteger("width", 200);
+  params->SetInteger("height", 400);
+  SendCommand("Browser.createTarget", std::move(params), true);
+  std::string target_id2;
+  EXPECT_TRUE(result_->GetString("targetId", &target_id2));
+  EXPECT_EQ(3u, shell()->windows().size());
+  actual_size = (shell()->windows().back()->web_contents())
+                    ->GetRenderWidgetHostView()
+                    ->GetViewBounds()
+                    .size();
+  EXPECT_SIZE_EQ(gfx::Size(200, 400), actual_size);
+
+  // Close targets.
+  // TODO(eseckler): Since closing RenderViews may happen asynchronously, we
+  // currently don't verify that the commands actually close the shells.
+  bool success;
+  params.reset(new base::DictionaryValue());
+  params->SetString("targetId", target_id1);
+  SendCommand("Browser.closeTarget", std::move(params), true);
+  EXPECT_TRUE(result_->GetBoolean("success", &success));
+  EXPECT_TRUE(success);
+  params.reset(new base::DictionaryValue());
+  params->SetString("targetId", target_id2);
+  SendCommand("Browser.closeTarget", std::move(params), true);
+  EXPECT_TRUE(result_->GetBoolean("success", &success));
+  EXPECT_TRUE(success);
+}
+
+IN_PROC_BROWSER_TEST_F(DevToolsProtocolTest, BrowserGetAndSetFrameSize) {
+  NavigateToURLBlockUntilNavigationsComplete(shell(), GURL("about:blank"), 1);
+  Attach();
+  EXPECT_EQ(1u, shell()->windows().size());
+  int width, height = 0;
+
+  // Get default size.
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  params->SetString("targetId", agent_host_->GetId());
+  SendCommand("Browser.getFrameSize", std::move(params), true);
+  EXPECT_TRUE(result_->GetInteger("width", &width));
+  EXPECT_TRUE(result_->GetInteger("height", &height));
+  EXPECT_SIZE_EQ(shell()->GetShellDefaultSize(), gfx::Size(width, height));
+
+  // Resize frame.
+  gfx::Size new_size(200, 400);
+  params.reset(new base::DictionaryValue());
+  params->SetString("targetId", agent_host_->GetId());
+  params->SetInteger("width", new_size.width());
+  params->SetInteger("height", new_size.height());
+  SendCommand("Browser.setFrameSize", std::move(params), true);
+  EXPECT_SIZE_EQ(new_size, (shell()->web_contents())
+                               ->GetRenderWidgetHostView()
+                               ->GetViewBounds()
+                               .size());
+
+  // Get updated size.
+  params.reset(new base::DictionaryValue());
+  params->SetString("targetId", agent_host_->GetId());
+  SendCommand("Browser.getFrameSize", std::move(params), true);
+  EXPECT_TRUE(result_->GetInteger("width", &width));
+  EXPECT_TRUE(result_->GetInteger("height", &height));
+  EXPECT_SIZE_EQ(new_size, gfx::Size(width, height));
 }
 
 namespace {
 class NavigationFinishedObserver : public content::WebContentsObserver {
  public:
   explicit NavigationFinishedObserver(WebContents* web_contents)
       : WebContentsObserver(web_contents),
         num_finished_(0),
         num_to_wait_for_(0) {}
 
@@ skipping 175 matching lines @@
   params->SetString("policy", "advance");
   params->SetInteger("budget", 1000);
   SendCommand("Emulation.setVirtualTimePolicy", std::move(params), true);
 
   WaitForNotification("Emulation.virtualTimeBudgetExpired");
 
   EXPECT_THAT(console_messages_, ElementsAre("before", "done", "after"));
 }
 
 }  // namespace content