Fix the content_browsertests everywhere maybe.

content/browser/renderer_host/render_widget_host_view_aura.cc

 // Copyright (c) 2012 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 "content/browser/renderer_host/render_widget_host_view_aura.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 448 matching lines @@
   window_->SetBounds(rect);
   host_->WasResized();
 }
 
 gfx::NativeView RenderWidgetHostViewAura::GetNativeView() const {
   return window_;
 }
 
 gfx::NativeViewId RenderWidgetHostViewAura::GetNativeViewId() const {
 #if defined(OS_WIN)
-  HWND window = window_->GetRootWindow()->GetAcceleratedWidget();
-  return reinterpret_cast<gfx::NativeViewId>(window);
-#else
+  aura::RootWindow* root_window = window_->GetRootWindow();

[Elliot Glaysher, 2013/01/18 20:31:38]

If you search through this file, you'll see that half the time we do NULL
checking on GetRootWindow(), and half the time we don't. The new changes to this
patch add NULL checks so that we don't crash when we are unparented to an aura
window hierarchy.

+  if (root_window) {
+    HWND window = root_window->GetAcceleratedWidget();
+    return reinterpret_cast<gfx::NativeViewId>(window);
+  }
+#endif
   return static_cast<gfx::NativeViewId>(NULL);
-#endif
 }
 
 gfx::NativeViewAccessible RenderWidgetHostViewAura::GetNativeViewAccessible() {
   NOTIMPLEMENTED();
   return static_cast<gfx::NativeViewAccessible>(NULL);
 }
 
 void RenderWidgetHostViewAura::MovePluginWindows(
     const gfx::Vector2d& scroll_offset,
     const std::vector<webkit::npapi::WebPluginGeometry>& plugin_window_moves) {
@@ skipping 130 matching lines @@
   gfx::Rect clip_rect;
   if (paint_canvas_) {
     SkRect sk_clip_rect;
     if (paint_canvas_->sk_canvas()->getClipBounds(&sk_clip_rect))
       clip_rect = gfx::ToEnclosingRect(gfx::SkRectToRectF(sk_clip_rect));
   }
 
   if (!scroll_rect.IsEmpty())
     SchedulePaintIfNotInClip(scroll_rect, clip_rect);
 
+#if defined(OS_WIN)
+  aura::RootWindow* root_window = window_->GetRootWindow();
+#endif
   for (size_t i = 0; i < copy_rects.size(); ++i) {
     gfx::Rect rect = gfx::SubtractRects(copy_rects[i], scroll_rect);
     if (rect.IsEmpty())
       continue;
 
     SchedulePaintIfNotInClip(rect, clip_rect);
 
 #if defined(OS_WIN)
-    // Send the invalid rect in screen coordinates.
-    gfx::Rect screen_rect = GetViewBounds();
-    gfx::Rect invalid_screen_rect(rect);
-    invalid_screen_rect.Offset(screen_rect.x(), screen_rect.y());
-    HWND hwnd = window_->GetRootWindow()->GetAcceleratedWidget();
-    PaintPluginWindowsHelper(hwnd, invalid_screen_rect);
+    if (root_window) {
+      // Send the invalid rect in screen coordinates.
+      gfx::Rect screen_rect = GetViewBounds();
+      gfx::Rect invalid_screen_rect(rect);
+      invalid_screen_rect.Offset(screen_rect.x(), screen_rect.y());
+      HWND hwnd = root_window->GetAcceleratedWidget();
+      PaintPluginWindowsHelper(hwnd, invalid_screen_rect);
+    }
 #endif  // defined(OS_WIN)
   }
 }
 
 void RenderWidgetHostViewAura::RenderViewGone(base::TerminationStatus status,
                                               int error_code) {
   UpdateCursorIfOverSelf();
   Destroy();
 }
 
@@ skipping 358 matching lines @@
   --render_widget_host_view->pending_thumbnail_tasks_;
 }
 
 void RenderWidgetHostViewAura::SetBackground(const SkBitmap& background) {
   RenderWidgetHostViewBase::SetBackground(background);
   host_->SetBackground(background);
   window_->layer()->SetFillsBoundsOpaquely(background.isOpaque());
 }
 
 void RenderWidgetHostViewAura::GetScreenInfo(WebScreenInfo* results) {
-  GetScreenInfoForWindow(results, window_);
+  GetScreenInfoForWindow(results, window_->GetRootWindow() ? window_ : NULL);
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetBoundsInRootWindow() {
   return window_->GetToplevelWindow()->GetBoundsInScreen();
 }
 
 void RenderWidgetHostViewAura::ProcessAckedTouchEvent(
     const WebKit::WebTouchEvent& touch_event, InputEventAckState ack_result) {
   ScopedVector<ui::TouchEvent> events;
   if (!MakeUITouchEventsFromWebTouchEvents(touch_event, &events))
@@ skipping 142 matching lines @@
 
 bool RenderWidgetHostViewAura::CanComposeInline() const {
   return can_compose_inline_;
 }
 
 gfx::Rect RenderWidgetHostViewAura::ConvertRectToScreen(const gfx::Rect& rect) {
   gfx::Point origin = rect.origin();
   gfx::Point end = gfx::Point(rect.right(), rect.bottom());
 
   aura::RootWindow* root_window = window_->GetRootWindow();
-  aura::client::ScreenPositionClient* screen_position_client =
-      aura::client::GetScreenPositionClient(root_window);
-  screen_position_client->ConvertPointToScreen(window_, &origin);
-  screen_position_client->ConvertPointToScreen(window_, &end);
-  return gfx::Rect(origin.x(),
-                   origin.y(),
-                   end.x() - origin.x(),
-                   end.y() - origin.y());
+  if (root_window) {
+    aura::client::ScreenPositionClient* screen_position_client =
+        aura::client::GetScreenPositionClient(root_window);
+    screen_position_client->ConvertPointToScreen(window_, &origin);
+    screen_position_client->ConvertPointToScreen(window_, &end);
+    return gfx::Rect(origin.x(),
+                     origin.y(),
+                     end.x() - origin.x(),
+                     end.y() - origin.y());
+  }
+
+  return rect;
 }
 
 gfx::Rect RenderWidgetHostViewAura::GetCaretBounds() {
   const gfx::Rect rect =
       gfx::UnionRects(selection_start_rect_, selection_end_rect_);
   return ConvertRectToScreen(rect);
 }
 
 bool RenderWidgetHostViewAura::GetCompositionCharacterBounds(uint32 index,
                                                              gfx::Rect* rect) {
@@ skipping 469 matching lines @@
 
   // If a gesture is not processed by the webpage, then WebKit processes it
   // (e.g. generates synthetic mouse events).
   event->SetHandled();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura, aura::client::ActivationDelegate implementation:
 
 bool RenderWidgetHostViewAura::ShouldActivate() const {
-  const ui::Event* event = window_->GetRootWindow()->current_event();
+  aura::RootWindow* root_window = window_->GetRootWindow();
+  if (!root_window)
+    return true;
+  const ui::Event* event = root_window->current_event();
   if (!event)
     return true;
   return is_fullscreen_;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // RenderWidgetHostViewAura,
 //     aura::client::ActivationChangeObserver implementation:
 
 void RenderWidgetHostViewAura::OnWindowActivated(aura::Window* gained_active,
@@ skipping 302 matching lines @@
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewAura(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(WebScreenInfo* results) {
   GetScreenInfoForWindow(results, NULL);
 }
 
 }  // namespace content