1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "content/browser/renderer_host/render_widget_host_view_aura.h"
6
7#include "base/basictypes.h"
8#include "base/message_loop/message_loop.h"
9#include "base/strings/utf_string_conversions.h"
10#include "content/browser/renderer_host/render_widget_host_delegate.h"
11#include "content/browser/renderer_host/render_widget_host_impl.h"
12#include "content/common/input_messages.h"
13#include "content/common/view_messages.h"
14#include "content/public/browser/render_widget_host_view.h"
15#include "content/public/test/mock_render_process_host.h"
16#include "content/public/test/test_browser_context.h"
17#include "ipc/ipc_test_sink.h"
18#include "testing/gtest/include/gtest/gtest.h"
19#include "ui/aura/client/aura_constants.h"
20#include "ui/aura/env.h"
21#include "ui/aura/layout_manager.h"
22#include "ui/aura/root_window.h"
23#include "ui/aura/test/aura_test_helper.h"
24#include "ui/aura/test/test_cursor_client.h"
25#include "ui/aura/test/test_screen.h"
26#include "ui/aura/test/test_window_delegate.h"
27#include "ui/aura/window.h"
28#include "ui/aura/window_observer.h"
29#include "ui/base/events/event.h"
30#include "ui/base/events/event_utils.h"
31#include "ui/base/ui_base_types.h"
32
33namespace content {
34namespace {
35class MockRenderWidgetHostDelegate : public RenderWidgetHostDelegate {
36 public:
37  MockRenderWidgetHostDelegate() {}
38  virtual ~MockRenderWidgetHostDelegate() {}
39};
40
41// Simple observer that keeps track of changes to a window for tests.
42class TestWindowObserver : public aura::WindowObserver {
43 public:
44  explicit TestWindowObserver(aura::Window* window_to_observe)
45      : window_(window_to_observe) {
46    window_->AddObserver(this);
47  }
48  virtual ~TestWindowObserver() {
49    if (window_)
50      window_->RemoveObserver(this);
51  }
52
53  bool destroyed() const { return destroyed_; }
54
55  // aura::WindowObserver overrides:
56  virtual void OnWindowDestroyed(aura::Window* window) OVERRIDE {
57    CHECK_EQ(window, window_);
58    destroyed_ = true;
59    window_ = NULL;
60  }
61
62 private:
63  // Window that we're observing, or NULL if it's been destroyed.
64  aura::Window* window_;
65
66  // Was |window_| destroyed?
67  bool destroyed_;
68
69  DISALLOW_COPY_AND_ASSIGN(TestWindowObserver);
70};
71
72class RenderWidgetHostViewAuraTest : public testing::Test {
73 public:
74  RenderWidgetHostViewAuraTest() {}
75
76  virtual void SetUp() {
77    aura_test_helper_.reset(new aura::test::AuraTestHelper(&message_loop_));
78    aura_test_helper_->SetUp();
79
80    browser_context_.reset(new TestBrowserContext);
81    MockRenderProcessHost* process_host =
82        new MockRenderProcessHost(browser_context_.get());
83
84    sink_ = &process_host->sink();
85
86    parent_host_ = new RenderWidgetHostImpl(
87        &delegate_, process_host, MSG_ROUTING_NONE);
88    parent_view_ = static_cast<RenderWidgetHostViewAura*>(
89        RenderWidgetHostView::CreateViewForWidget(parent_host_));
90    parent_view_->InitAsChild(NULL);
91    parent_view_->GetNativeView()->SetDefaultParentByRootWindow(
92        aura_test_helper_->root_window(), gfx::Rect());
93
94    widget_host_ = new RenderWidgetHostImpl(
95        &delegate_, process_host, MSG_ROUTING_NONE);
96    widget_host_->Init();
97    view_ = static_cast<RenderWidgetHostViewAura*>(
98        RenderWidgetHostView::CreateViewForWidget(widget_host_));
99  }
100
101  virtual void TearDown() {
102    sink_ = NULL;
103    if (view_)
104      view_->Destroy();
105    delete widget_host_;
106
107    parent_view_->Destroy();
108    delete parent_host_;
109
110    browser_context_.reset();
111    aura_test_helper_->TearDown();
112
113    message_loop_.DeleteSoon(FROM_HERE, browser_context_.release());
114    message_loop_.RunUntilIdle();
115  }
116
117 protected:
118  base::MessageLoopForUI message_loop_;
119  scoped_ptr<aura::test::AuraTestHelper> aura_test_helper_;
120  scoped_ptr<BrowserContext> browser_context_;
121  MockRenderWidgetHostDelegate delegate_;
122
123  // Tests should set these to NULL if they've already triggered their
124  // destruction.
125  RenderWidgetHostImpl* parent_host_;
126  RenderWidgetHostViewAura* parent_view_;
127
128  // Tests should set these to NULL if they've already triggered their
129  // destruction.
130  RenderWidgetHostImpl* widget_host_;
131  RenderWidgetHostViewAura* view_;
132
133  IPC::TestSink* sink_;
134
135 private:
136  DISALLOW_COPY_AND_ASSIGN(RenderWidgetHostViewAuraTest);
137};
138
139// A layout manager that always resizes a child to the root window size.
140class FullscreenLayoutManager : public aura::LayoutManager {
141 public:
142  explicit FullscreenLayoutManager(aura::RootWindow* owner)
143      : owner_(owner) {}
144  virtual ~FullscreenLayoutManager() {}
145
146  // Overridden from aura::LayoutManager:
147  virtual void OnWindowResized() OVERRIDE {
148    aura::Window::Windows::const_iterator i;
149    for (i = owner_->children().begin(); i != owner_->children().end(); ++i) {
150      (*i)->SetBounds(gfx::Rect());
151    }
152  }
153  virtual void OnWindowAddedToLayout(aura::Window* child) OVERRIDE {
154    child->SetBounds(gfx::Rect());
155  }
156  virtual void OnWillRemoveWindowFromLayout(aura::Window* child) OVERRIDE {
157  }
158  virtual void OnWindowRemovedFromLayout(aura::Window* child) OVERRIDE {
159  }
160  virtual void OnChildWindowVisibilityChanged(aura::Window* child,
161                                              bool visible) OVERRIDE {
162  }
163  virtual void SetChildBounds(aura::Window* child,
164                              const gfx::Rect& requested_bounds) OVERRIDE {
165    SetChildBoundsDirect(child, gfx::Rect(owner_->bounds().size()));
166  }
167
168 private:
169  aura::RootWindow* owner_;
170  DISALLOW_COPY_AND_ASSIGN(FullscreenLayoutManager);
171};
172
173}  // namespace
174
175// Checks that a fullscreen view has the correct show-state and receives the
176// focus.
177TEST_F(RenderWidgetHostViewAuraTest, FocusFullscreen) {
178  view_->InitAsFullscreen(parent_view_);
179  aura::Window* window = view_->GetNativeView();
180  ASSERT_TRUE(window != NULL);
181  EXPECT_EQ(ui::SHOW_STATE_FULLSCREEN,
182            window->GetProperty(aura::client::kShowStateKey));
183
184  // Check that we requested and received the focus.
185  EXPECT_TRUE(window->HasFocus());
186
187  // Check that we'll also say it's okay to activate the window when there's an
188  // ActivationClient defined.
189  EXPECT_TRUE(view_->ShouldActivate());
190}
191
192// Checks that a fullscreen view is destroyed when it loses the focus.
193TEST_F(RenderWidgetHostViewAuraTest, DestroyFullscreenOnBlur) {
194  view_->InitAsFullscreen(parent_view_);
195  aura::Window* window = view_->GetNativeView();
196  ASSERT_TRUE(window != NULL);
197  ASSERT_TRUE(window->HasFocus());
198
199  // After we create and focus another window, the RWHVA's window should be
200  // destroyed.
201  TestWindowObserver observer(window);
202  aura::test::TestWindowDelegate delegate;
203  scoped_ptr<aura::Window> sibling(new aura::Window(&delegate));
204  sibling->Init(ui::LAYER_TEXTURED);
205  sibling->Show();
206  window->parent()->AddChild(sibling.get());
207  sibling->Focus();
208  ASSERT_TRUE(sibling->HasFocus());
209  ASSERT_TRUE(observer.destroyed());
210
211  widget_host_ = NULL;
212  view_ = NULL;
213}
214
215// Checks that IME-composition-event state is maintained correctly.
216TEST_F(RenderWidgetHostViewAuraTest, SetCompositionText) {
217  view_->InitAsChild(NULL);
218  view_->Show();
219
220  ui::CompositionText composition_text;
221  composition_text.text = ASCIIToUTF16("|a|b");
222
223  // Focused segment
224  composition_text.underlines.push_back(
225      ui::CompositionUnderline(0, 3, 0xff000000, true));
226
227  // Non-focused segment
228  composition_text.underlines.push_back(
229      ui::CompositionUnderline(3, 4, 0xff000000, false));
230
231  const ui::CompositionUnderlines& underlines = composition_text.underlines;
232
233  // Caret is at the end. (This emulates Japanese MSIME 2007 and later)
234  composition_text.selection = ui::Range(4);
235
236  sink_->ClearMessages();
237  view_->SetCompositionText(composition_text);
238  EXPECT_TRUE(view_->has_composition_text_);
239  {
240    const IPC::Message* msg =
241      sink_->GetFirstMessageMatching(ViewMsg_ImeSetComposition::ID);
242    ASSERT_TRUE(msg != NULL);
243
244    ViewMsg_ImeSetComposition::Param params;
245    ViewMsg_ImeSetComposition::Read(msg, &params);
246    // composition text
247    EXPECT_EQ(composition_text.text, params.a);
248    // underlines
249    ASSERT_EQ(underlines.size(), params.b.size());
250    for (size_t i = 0; i < underlines.size(); ++i) {
251      EXPECT_EQ(underlines[i].start_offset, params.b[i].startOffset);
252      EXPECT_EQ(underlines[i].end_offset, params.b[i].endOffset);
253      EXPECT_EQ(underlines[i].color, params.b[i].color);
254      EXPECT_EQ(underlines[i].thick, params.b[i].thick);
255    }
256    // highlighted range
257    EXPECT_EQ(4, params.c) << "Should be the same to the caret pos";
258    EXPECT_EQ(4, params.d) << "Should be the same to the caret pos";
259  }
260
261  view_->ImeCancelComposition();
262  EXPECT_FALSE(view_->has_composition_text_);
263}
264
265// Checks that touch-event state is maintained correctly.
266TEST_F(RenderWidgetHostViewAuraTest, TouchEventState) {
267  view_->InitAsChild(NULL);
268  view_->Show();
269
270  // Start with no touch-event handler in the renderer.
271  widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false));
272  EXPECT_FALSE(widget_host_->ShouldForwardTouchEvent());
273
274  ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
275                       gfx::Point(30, 30),
276                       0,
277                       ui::EventTimeForNow());
278  ui::TouchEvent move(ui::ET_TOUCH_MOVED,
279                      gfx::Point(20, 20),
280                      0,
281                      ui::EventTimeForNow());
282  ui::TouchEvent release(ui::ET_TOUCH_RELEASED,
283                         gfx::Point(20, 20),
284                         0,
285                         ui::EventTimeForNow());
286
287  view_->OnTouchEvent(&press);
288  EXPECT_FALSE(press.handled());
289  EXPECT_EQ(WebKit::WebInputEvent::TouchStart, view_->touch_event_.type);
290  EXPECT_EQ(1U, view_->touch_event_.touchesLength);
291  EXPECT_EQ(WebKit::WebTouchPoint::StatePressed,
292            view_->touch_event_.touches[0].state);
293
294  view_->OnTouchEvent(&move);
295  EXPECT_FALSE(move.handled());
296  EXPECT_EQ(WebKit::WebInputEvent::TouchMove, view_->touch_event_.type);
297  EXPECT_EQ(1U, view_->touch_event_.touchesLength);
298  EXPECT_EQ(WebKit::WebTouchPoint::StateMoved,
299            view_->touch_event_.touches[0].state);
300
301  view_->OnTouchEvent(&release);
302  EXPECT_FALSE(release.handled());
303  EXPECT_EQ(WebKit::WebInputEvent::TouchEnd, view_->touch_event_.type);
304  EXPECT_EQ(0U, view_->touch_event_.touchesLength);
305
306  // Now install some touch-event handlers and do the same steps. The touch
307  // events should now be consumed. However, the touch-event state should be
308  // updated as before.
309  widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
310  EXPECT_TRUE(widget_host_->ShouldForwardTouchEvent());
311
312  view_->OnTouchEvent(&press);
313  EXPECT_TRUE(press.stopped_propagation());
314  EXPECT_EQ(WebKit::WebInputEvent::TouchStart, view_->touch_event_.type);
315  EXPECT_EQ(1U, view_->touch_event_.touchesLength);
316  EXPECT_EQ(WebKit::WebTouchPoint::StatePressed,
317            view_->touch_event_.touches[0].state);
318
319  view_->OnTouchEvent(&move);
320  EXPECT_TRUE(move.stopped_propagation());
321  EXPECT_EQ(WebKit::WebInputEvent::TouchMove, view_->touch_event_.type);
322  EXPECT_EQ(1U, view_->touch_event_.touchesLength);
323  EXPECT_EQ(WebKit::WebTouchPoint::StateMoved,
324            view_->touch_event_.touches[0].state);
325
326  view_->OnTouchEvent(&release);
327  EXPECT_TRUE(release.stopped_propagation());
328  EXPECT_EQ(WebKit::WebInputEvent::TouchEnd, view_->touch_event_.type);
329  EXPECT_EQ(0U, view_->touch_event_.touchesLength);
330
331  // Now start a touch event, and remove the event-handlers before the release.
332  view_->OnTouchEvent(&press);
333  EXPECT_TRUE(press.stopped_propagation());
334  EXPECT_EQ(WebKit::WebInputEvent::TouchStart, view_->touch_event_.type);
335  EXPECT_EQ(1U, view_->touch_event_.touchesLength);
336  EXPECT_EQ(WebKit::WebTouchPoint::StatePressed,
337            view_->touch_event_.touches[0].state);
338
339  widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, false));
340  EXPECT_FALSE(widget_host_->ShouldForwardTouchEvent());
341
342  ui::TouchEvent move2(ui::ET_TOUCH_MOVED, gfx::Point(20, 20), 0,
343      base::Time::NowFromSystemTime() - base::Time());
344  view_->OnTouchEvent(&move2);
345  EXPECT_FALSE(move2.handled());
346  EXPECT_EQ(WebKit::WebInputEvent::TouchMove, view_->touch_event_.type);
347  EXPECT_EQ(1U, view_->touch_event_.touchesLength);
348  EXPECT_EQ(WebKit::WebTouchPoint::StateMoved,
349            view_->touch_event_.touches[0].state);
350
351  ui::TouchEvent release2(ui::ET_TOUCH_RELEASED, gfx::Point(20, 20), 0,
352      base::Time::NowFromSystemTime() - base::Time());
353  view_->OnTouchEvent(&release2);
354  EXPECT_FALSE(release2.handled());
355  EXPECT_EQ(WebKit::WebInputEvent::TouchEnd, view_->touch_event_.type);
356  EXPECT_EQ(0U, view_->touch_event_.touchesLength);
357}
358
359// Checks that touch-events are queued properly when there is a touch-event
360// handler on the page.
361TEST_F(RenderWidgetHostViewAuraTest, TouchEventSyncAsync) {
362  view_->InitAsChild(NULL);
363  view_->Show();
364
365  widget_host_->OnMessageReceived(ViewHostMsg_HasTouchEventHandlers(0, true));
366  EXPECT_TRUE(widget_host_->ShouldForwardTouchEvent());
367
368  ui::TouchEvent press(ui::ET_TOUCH_PRESSED,
369                       gfx::Point(30, 30),
370                       0,
371                       ui::EventTimeForNow());
372  ui::TouchEvent move(ui::ET_TOUCH_MOVED,
373                      gfx::Point(20, 20),
374                      0,
375                      ui::EventTimeForNow());
376  ui::TouchEvent release(ui::ET_TOUCH_RELEASED,
377                         gfx::Point(20, 20),
378                         0,
379                         ui::EventTimeForNow());
380
381  view_->OnTouchEvent(&press);
382  EXPECT_TRUE(press.stopped_propagation());
383  EXPECT_EQ(WebKit::WebInputEvent::TouchStart, view_->touch_event_.type);
384  EXPECT_EQ(1U, view_->touch_event_.touchesLength);
385  EXPECT_EQ(WebKit::WebTouchPoint::StatePressed,
386            view_->touch_event_.touches[0].state);
387
388  view_->OnTouchEvent(&move);
389  EXPECT_TRUE(move.stopped_propagation());
390  EXPECT_EQ(WebKit::WebInputEvent::TouchMove, view_->touch_event_.type);
391  EXPECT_EQ(1U, view_->touch_event_.touchesLength);
392  EXPECT_EQ(WebKit::WebTouchPoint::StateMoved,
393            view_->touch_event_.touches[0].state);
394
395  // Send the same move event. Since the point hasn't moved, it won't affect the
396  // queue. However, the view should consume the event.
397  view_->OnTouchEvent(&move);
398  EXPECT_TRUE(move.stopped_propagation());
399  EXPECT_EQ(WebKit::WebInputEvent::TouchMove, view_->touch_event_.type);
400  EXPECT_EQ(1U, view_->touch_event_.touchesLength);
401  EXPECT_EQ(WebKit::WebTouchPoint::StateMoved,
402            view_->touch_event_.touches[0].state);
403
404  view_->OnTouchEvent(&release);
405  EXPECT_TRUE(release.stopped_propagation());
406  EXPECT_EQ(WebKit::WebInputEvent::TouchEnd, view_->touch_event_.type);
407  EXPECT_EQ(0U, view_->touch_event_.touchesLength);
408}
409
410TEST_F(RenderWidgetHostViewAuraTest, PhysicalBackingSizeWithScale) {
411  view_->InitAsChild(NULL);
412  view_->GetNativeView()->SetDefaultParentByRootWindow(
413      parent_view_->GetNativeView()->GetRootWindow(), gfx::Rect());
414  sink_->ClearMessages();
415  view_->SetSize(gfx::Size(100, 100));
416  EXPECT_EQ("100x100", view_->GetPhysicalBackingSize().ToString());
417  EXPECT_EQ(1u, sink_->message_count());
418  EXPECT_EQ(ViewMsg_Resize::ID, sink_->GetMessageAt(0)->type());
419  {
420    const IPC::Message* msg = sink_->GetMessageAt(0);
421    EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
422    ViewMsg_Resize::Param params;
423    ViewMsg_Resize::Read(msg, &params);
424    EXPECT_EQ("100x100", params.a.new_size.ToString());  // dip size
425    EXPECT_EQ("100x100",
426        params.a.physical_backing_size.ToString());  // backing size
427  }
428
429  widget_host_->ResetSizeAndRepaintPendingFlags();
430  sink_->ClearMessages();
431
432  aura_test_helper_->test_screen()->SetDeviceScaleFactor(2.0f);
433  EXPECT_EQ("200x200", view_->GetPhysicalBackingSize().ToString());
434  // Extra ScreenInfoChanged message for |parent_view_|.
435  EXPECT_EQ(1u, sink_->message_count());
436  {
437    const IPC::Message* msg = sink_->GetMessageAt(0);
438    EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
439    ViewMsg_Resize::Param params;
440    ViewMsg_Resize::Read(msg, &params);
441    EXPECT_EQ(2.0f, params.a.screen_info.deviceScaleFactor);
442    EXPECT_EQ("100x100", params.a.new_size.ToString());  // dip size
443    EXPECT_EQ("200x200",
444        params.a.physical_backing_size.ToString());  // backing size
445  }
446
447  widget_host_->ResetSizeAndRepaintPendingFlags();
448  sink_->ClearMessages();
449
450  aura_test_helper_->test_screen()->SetDeviceScaleFactor(1.0f);
451  // Extra ScreenInfoChanged message for |parent_view_|.
452  EXPECT_EQ(1u, sink_->message_count());
453  EXPECT_EQ("100x100", view_->GetPhysicalBackingSize().ToString());
454  {
455    const IPC::Message* msg = sink_->GetMessageAt(0);
456    EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
457    ViewMsg_Resize::Param params;
458    ViewMsg_Resize::Read(msg, &params);
459    EXPECT_EQ(1.0f, params.a.screen_info.deviceScaleFactor);
460    EXPECT_EQ("100x100", params.a.new_size.ToString());  // dip size
461    EXPECT_EQ("100x100",
462        params.a.physical_backing_size.ToString());  // backing size
463  }
464}
465
466// Checks that InputMsg_CursorVisibilityChange IPC messages are dispatched
467// to the renderer at the correct times.
468TEST_F(RenderWidgetHostViewAuraTest, CursorVisibilityChange) {
469  view_->InitAsChild(NULL);
470  view_->GetNativeView()->SetDefaultParentByRootWindow(
471      parent_view_->GetNativeView()->GetRootWindow(), gfx::Rect());
472  view_->SetSize(gfx::Size(100, 100));
473
474  aura::test::TestCursorClient cursor_client(
475      parent_view_->GetNativeView()->GetRootWindow());
476
477  cursor_client.AddObserver(view_);
478
479  // Expect a message the first time the cursor is shown.
480  view_->WasShown();
481  sink_->ClearMessages();
482  cursor_client.ShowCursor();
483  EXPECT_EQ(1u, sink_->message_count());
484  EXPECT_TRUE(sink_->GetUniqueMessageMatching(
485      InputMsg_CursorVisibilityChange::ID));
486
487  // No message expected if the renderer already knows the cursor is visible.
488  sink_->ClearMessages();
489  cursor_client.ShowCursor();
490  EXPECT_EQ(0u, sink_->message_count());
491
492  // Hiding the cursor should send a message.
493  sink_->ClearMessages();
494  cursor_client.HideCursor();
495  EXPECT_EQ(1u, sink_->message_count());
496  EXPECT_TRUE(sink_->GetUniqueMessageMatching(
497      InputMsg_CursorVisibilityChange::ID));
498
499  // No message expected if the renderer already knows the cursor is invisible.
500  sink_->ClearMessages();
501  cursor_client.HideCursor();
502  EXPECT_EQ(0u, sink_->message_count());
503
504  // No messages should be sent while the view is invisible.
505  view_->WasHidden();
506  sink_->ClearMessages();
507  cursor_client.ShowCursor();
508  EXPECT_EQ(0u, sink_->message_count());
509  cursor_client.HideCursor();
510  EXPECT_EQ(0u, sink_->message_count());
511
512  // Show the view. Since the cursor was invisible when the view was hidden,
513  // no message should be sent.
514  sink_->ClearMessages();
515  view_->WasShown();
516  EXPECT_FALSE(sink_->GetUniqueMessageMatching(
517      InputMsg_CursorVisibilityChange::ID));
518
519  // No message expected if the renderer already knows the cursor is invisible.
520  sink_->ClearMessages();
521  cursor_client.HideCursor();
522  EXPECT_EQ(0u, sink_->message_count());
523
524  // Showing the cursor should send a message.
525  sink_->ClearMessages();
526  cursor_client.ShowCursor();
527  EXPECT_EQ(1u, sink_->message_count());
528  EXPECT_TRUE(sink_->GetUniqueMessageMatching(
529      InputMsg_CursorVisibilityChange::ID));
530
531  // No messages should be sent while the view is invisible.
532  view_->WasHidden();
533  sink_->ClearMessages();
534  cursor_client.HideCursor();
535  EXPECT_EQ(0u, sink_->message_count());
536
537  // Show the view. Since the cursor was visible when the view was hidden,
538  // a message is expected to be sent.
539  sink_->ClearMessages();
540  view_->WasShown();
541  EXPECT_TRUE(sink_->GetUniqueMessageMatching(
542      InputMsg_CursorVisibilityChange::ID));
543
544  cursor_client.RemoveObserver(view_);
545}
546
547// Resizing in fullscreen mode should send the up-to-date screen info.
548TEST_F(RenderWidgetHostViewAuraTest, FullscreenResize) {
549  aura::RootWindow* root_window = aura_test_helper_->root_window();
550  root_window->SetLayoutManager(new FullscreenLayoutManager(root_window));
551  view_->InitAsFullscreen(parent_view_);
552  view_->WasShown();
553  widget_host_->ResetSizeAndRepaintPendingFlags();
554  sink_->ClearMessages();
555
556  // Call WasResized to flush the old screen info.
557  view_->GetRenderWidgetHost()->WasResized();
558  {
559    // 0 is CreatingNew message.
560    const IPC::Message* msg = sink_->GetMessageAt(0);
561    EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
562    ViewMsg_Resize::Param params;
563    ViewMsg_Resize::Read(msg, &params);
564    EXPECT_EQ("0,0 800x600",
565              gfx::Rect(params.a.screen_info.availableRect).ToString());
566    EXPECT_EQ("800x600", params.a.new_size.ToString());
567  }
568
569  widget_host_->ResetSizeAndRepaintPendingFlags();
570  sink_->ClearMessages();
571
572  // Make sure the corrent screen size is set along in the resize
573  // request when the screen size has changed.
574  aura_test_helper_->test_screen()->SetUIScale(0.5);
575  EXPECT_EQ(1u, sink_->message_count());
576  {
577    const IPC::Message* msg = sink_->GetMessageAt(0);
578    EXPECT_EQ(ViewMsg_Resize::ID, msg->type());
579    ViewMsg_Resize::Param params;
580    ViewMsg_Resize::Read(msg, &params);
581    EXPECT_EQ("0,0 1600x1200",
582              gfx::Rect(params.a.screen_info.availableRect).ToString());
583    EXPECT_EQ("1600x1200", params.a.new_size.ToString());
584  }
585}
586
587}  // namespace content
588