Page::chrome() should return a reference.

Source/core/page/DOMWindow.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 301 matching lines @@
 // 1) Validates the pending changes are not changing any value to NaN; in that case keep original value.
 // 2) Constrains the window rect to the minimum window size and no bigger than the float rect's dimensions.
 // 3) Constrains the window rect to within the top and left boundaries of the available screen rect.
 // 4) Constrains the window rect to within the bottom and right boundaries of the available screen rect.
 // 5) Translate the window rect coordinates to be within the coordinate space of the screen.
 FloatRect DOMWindow::adjustWindowRect(Page* page, const FloatRect& pendingChanges)
 {
     ASSERT(page);
 
     FloatRect screen = screenAvailableRect(page->mainFrame()->view());
-    FloatRect window = page->chrome()->windowRect();
+    FloatRect window = page->chrome().windowRect();
 
     // Make sure we're in a valid state before adjusting dimensions.
     ASSERT(std::isfinite(screen.x()));
     ASSERT(std::isfinite(screen.y()));
     ASSERT(std::isfinite(screen.width()));
     ASSERT(std::isfinite(screen.height()));
     ASSERT(std::isfinite(window.x()));
     ASSERT(std::isfinite(window.y()));
     ASSERT(std::isfinite(window.width()));
     ASSERT(std::isfinite(window.height()));
 
     // Update window values if new requested values are not NaN.
     if (!std::isnan(pendingChanges.x()))
         window.setX(pendingChanges.x());
     if (!std::isnan(pendingChanges.y()))
         window.setY(pendingChanges.y());
     if (!std::isnan(pendingChanges.width()))
         window.setWidth(pendingChanges.width());
     if (!std::isnan(pendingChanges.height()))
         window.setHeight(pendingChanges.height());
 
-    FloatSize minimumSize = page->chrome()->client()->minimumWindowSize();
+    FloatSize minimumSize = page->chrome().client()->minimumWindowSize();
     // Let size 0 pass through, since that indicates default size, not minimum size.
     if (window.width())
         window.setWidth(min(max(minimumSize.width(), window.width()), screen.width()));
     if (window.height())
         window.setHeight(min(max(minimumSize.height(), window.height()), screen.height()));
 
     // Constrain the window position within the valid screen area.
     window.setX(max(screen.x(), min(window.x(), screen.maxX() - window.width())));
     window.setY(max(screen.y(), min(window.y(), screen.maxY() - window.height())));
 
@@ skipping 16 matching lines @@
     return m_frame && allowPopUp(m_frame);
 }
 
 bool DOMWindow::canShowModalDialog(const Frame* frame)
 {
     if (!frame)
         return false;
     Page* page = frame->page();
     if (!page)
         return false;
-    return page->chrome()->canRunModal();
+    return page->chrome().canRunModal();
 }
 
 bool DOMWindow::canShowModalDialogNow(const Frame* frame)
 {
     if (!frame)
         return false;
     Page* page = frame->page();
     if (!page)
         return false;
-    return page->chrome()->canRunModalNow();
+    return page->chrome().canRunModalNow();
 }
 
 DOMWindow::DOMWindow(Document* document)
     : ContextDestructionObserver(document)
     , FrameDestructionObserver(document->frame())
     , m_shouldPrintWhenFinishedLoading(false)
 {
     ASSERT(frame());
     ASSERT(DOMWindow::document());
     ScriptWrappable::init(this);
@@ skipping 458 matching lines @@
     bool allowFocus = WindowFocusAllowedIndicator::windowFocusAllowed();
     if (context) {
         ASSERT(isMainThread());
         Document* activeDocument = toDocument(context);
         if (opener() && opener() != this && activeDocument->domWindow() == opener())
             allowFocus = true;
     }
 
     // If we're a top level window, bring the window to the front.
     if (m_frame == page->mainFrame() && allowFocus)
-        page->chrome()->focus();
+        page->chrome().focus();
 
     if (!m_frame)
         return;
 
     // Clear the current frame's focused node if a new frame is about to be focused.
     Frame* focusedFrame = page->focusController()->focusedFrame();
     if (focusedFrame && focusedFrame != m_frame)
         focusedFrame->document()->setFocusedNode(0);
 
     m_frame->eventHandler()->focusDocumentView();
@@ skipping 27 matching lines @@
 
     Settings* settings = m_frame->settings();
     bool allowScriptsToCloseWindows = settings && settings->allowScriptsToCloseWindows();
 
     if (!(page->openedByDOM() || page->backForward()->count() <= 1 || allowScriptsToCloseWindows))
         return;
 
     if (!m_frame->loader()->shouldClose())
         return;
 
-    page->chrome()->closeWindowSoon();
+    page->chrome().closeWindowSoon();
 }
 
 void DOMWindow::print()
 {
     if (!m_frame)
         return;
 
     Page* page = m_frame->page();
     if (!page)
         return;
 
     if (m_frame->loader()->activeDocumentLoader()->isLoading()) {
         m_shouldPrintWhenFinishedLoading = true;
         return;
     }
     m_shouldPrintWhenFinishedLoading = false;
-    page->chrome()->print(m_frame);
+    page->chrome().print(m_frame);
 }
 
 void DOMWindow::stop()
 {
     if (!m_frame)
         return;
 
     // We must check whether the load is complete asynchronously, because we might still be parsing
     // the document until the callstack unwinds.
     m_frame->loader()->stopForUserCancel(true);
 }
 
 void DOMWindow::alert(const String& message)
 {
     if (!m_frame)
         return;
 
     m_frame->document()->updateStyleIfNeeded();
 
     Page* page = m_frame->page();
     if (!page)
         return;
 
-    page->chrome()->runJavaScriptAlert(m_frame, message);
+    page->chrome().runJavaScriptAlert(m_frame, message);
 }
 
 bool DOMWindow::confirm(const String& message)
 {
     if (!m_frame)
         return false;
 
     m_frame->document()->updateStyleIfNeeded();
 
     Page* page = m_frame->page();
     if (!page)
         return false;
 
-    return page->chrome()->runJavaScriptConfirm(m_frame, message);
+    return page->chrome().runJavaScriptConfirm(m_frame, message);
 }
 
 String DOMWindow::prompt(const String& message, const String& defaultValue)
 {
     if (!m_frame)
         return String();
 
     m_frame->document()->updateStyleIfNeeded();
 
     Page* page = m_frame->page();
     if (!page)
         return String();
 
     String returnValue;
-    if (page->chrome()->runJavaScriptPrompt(m_frame, message, defaultValue, returnValue))
+    if (page->chrome().runJavaScriptPrompt(m_frame, message, defaultValue, returnValue))
         return returnValue;
 
     return String();
 }
 
 String DOMWindow::btoa(const String& stringToEncode, ExceptionCode& ec)
 {
     if (stringToEncode.isNull())
         return String();
 
@@ skipping 40 matching lines @@
 
 int DOMWindow::outerHeight() const
 {
     if (!m_frame)
         return 0;
 
     Page* page = m_frame->page();
     if (!page)
         return 0;
 
-    return static_cast<int>(page->chrome()->windowRect().height());
+    return static_cast<int>(page->chrome().windowRect().height());
 }
 
 int DOMWindow::outerWidth() const
 {
     if (!m_frame)
         return 0;
 
     Page* page = m_frame->page();
     if (!page)
         return 0;
 
-    return static_cast<int>(page->chrome()->windowRect().width());
+    return static_cast<int>(page->chrome().windowRect().width());
 }
 
 int DOMWindow::innerHeight() const
 {
     if (!m_frame)
         return 0;
 
     FrameView* view = m_frame->view();
     if (!view)
         return 0;
@@ skipping 19 matching lines @@
 
 int DOMWindow::screenX() const
 {
     if (!m_frame)
         return 0;
 
     Page* page = m_frame->page();
     if (!page)
         return 0;
 
-    return static_cast<int>(page->chrome()->windowRect().x());
+    return static_cast<int>(page->chrome().windowRect().x());
 }
 
 int DOMWindow::screenY() const
 {
     if (!m_frame)
         return 0;
 
     Page* page = m_frame->page();
     if (!page)
         return 0;
 
-    return static_cast<int>(page->chrome()->windowRect().y());
+    return static_cast<int>(page->chrome().windowRect().y());
 }
 
 int DOMWindow::scrollX() const
 {
     if (!m_frame)
         return 0;
 
     FrameView* view = m_frame->view();
     if (!view)
         return 0;
@@ skipping 52 matching lines @@
     m_status = string;
 
     if (!m_frame)
         return;
 
     Page* page = m_frame->page();
     if (!page)
         return;
 
     ASSERT(m_frame->document()); // Client calls shouldn't be made when the frame is in inconsistent state.
-    page->chrome()->setStatusbarText(m_frame, m_status);
+    page->chrome().setStatusbarText(m_frame, m_status);
 }
 
 void DOMWindow::setDefaultStatus(const String& string)
 {
     m_defaultStatus = string;
 
     if (!m_frame)
         return;
 
     Page* page = m_frame->page();
     if (!page)
         return;
 
     ASSERT(m_frame->document()); // Client calls shouldn't be made when the frame is in inconsistent state.
-    page->chrome()->setStatusbarText(m_frame, m_defaultStatus);
+    page->chrome().setStatusbarText(m_frame, m_defaultStatus);
 }
 
 DOMWindow* DOMWindow::self() const
 {
     if (!m_frame)
         return 0;
 
     return m_frame->document()->domWindow();
 }
 
@@ skipping 152 matching lines @@
     if (!m_frame)
         return;
 
     Page* page = m_frame->page();
     if (!page)
         return;
 
     if (m_frame != page->mainFrame())
         return;
 
-    FloatRect fr = page->chrome()->windowRect();
+    FloatRect fr = page->chrome().windowRect();
     FloatRect update = fr;
     update.move(x, y);
     // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
-    page->chrome()->setWindowRect(adjustWindowRect(page, update));
+    page->chrome().setWindowRect(adjustWindowRect(page, update));
 }
 
 void DOMWindow::moveTo(float x, float y) const
 {
     if (!m_frame)
         return;
 
     Page* page = m_frame->page();
     if (!page)
         return;
 
     if (m_frame != page->mainFrame())
         return;
 
-    FloatRect fr = page->chrome()->windowRect();
+    FloatRect fr = page->chrome().windowRect();
     FloatRect sr = screenAvailableRect(page->mainFrame()->view());
     fr.setLocation(sr.location());
     FloatRect update = fr;
     update.move(x, y);
     // Security check (the spec talks about UniversalBrowserWrite to disable this check...)
-    page->chrome()->setWindowRect(adjustWindowRect(page, update));
+    page->chrome().setWindowRect(adjustWindowRect(page, update));
 }
 
 void DOMWindow::resizeBy(float x, float y) const
 {
     if (!m_frame)
         return;
 
     Page* page = m_frame->page();
     if (!page)
         return;
 
     if (m_frame != page->mainFrame())
         return;
 
-    FloatRect fr = page->chrome()->windowRect();
+    FloatRect fr = page->chrome().windowRect();
     FloatSize dest = fr.size() + FloatSize(x, y);
     FloatRect update(fr.location(), dest);
-    page->chrome()->setWindowRect(adjustWindowRect(page, update));
+    page->chrome().setWindowRect(adjustWindowRect(page, update));
 }
 
 void DOMWindow::resizeTo(float width, float height) const
 {
     if (!m_frame)
         return;
 
     Page* page = m_frame->page();
     if (!page)
         return;
 
     if (m_frame != page->mainFrame())
         return;
 
-    FloatRect fr = page->chrome()->windowRect();
+    FloatRect fr = page->chrome().windowRect();
     FloatSize dest = FloatSize(width, height);
     FloatRect update(fr.location(), dest);
-    page->chrome()->setWindowRect(adjustWindowRect(page, update));
+    page->chrome().setWindowRect(adjustWindowRect(page, update));
 }
 
 int DOMWindow::setTimeout(PassOwnPtr<ScheduledAction> action, int timeout, ExceptionCode& ec)
 {
     ScriptExecutionContext* context = scriptExecutionContext();
     if (!context) {
         ec = INVALID_ACCESS_ERR;
         return -1;
     }
     return DOMTimer::install(context, action, timeout, true);
@@ skipping 413 matching lines @@
 
     if (!canShowModalDialogNow(m_frame) || !firstWindow->allowPopUp())
         return;
 
     WindowFeatures windowFeatures(dialogFeaturesString, screenAvailableRect(m_frame->view()));
     Frame* dialogFrame = createWindow(urlString, emptyAtom, windowFeatures,
         activeWindow, firstFrame, m_frame, function, functionContext);
     if (!dialogFrame)
         return;
     UserGestureIndicatorDisabler disabler;
-    dialogFrame->page()->chrome()->runModal();
+    dialogFrame->page()->chrome().runModal();
 }
 
 DOMWindow* DOMWindow::anonymousIndexedGetter(uint32_t index)
 {
     Frame* frame = this->frame();
     if (!frame)
         return 0;
 
     Frame* child = frame->tree()->scopedChild(index);
     if (child)
         return child->document()->domWindow();
 
     return 0;
 }
 
 
 } // namespace WebCore