/*
 * Copyright (C) 2006, 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc. All
 * Rights Reserved.
 * Copyright (C) 2008 Torch Mobile Inc. All rights reserved.
 * (http://www.torchmobile.com/)
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public License
 * along with this library; see the file COPYING.LIB.  If not, write to
 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 */

#include "core/page/Page.h"

#include "bindings/core/v8/ScriptController.h"
#include "core/css/resolver/ViewportStyleResolver.h"
#include "core/dom/ClientRectList.h"
#include "core/dom/StyleChangeReason.h"
#include "core/dom/StyleEngine.h"
#include "core/dom/VisitedLinkState.h"
#include "core/editing/DragCaret.h"
#include "core/editing/markers/DocumentMarkerController.h"
#include "core/events/Event.h"
#include "core/frame/BrowserControls.h"
#include "core/frame/DOMTimer.h"
#include "core/frame/EventHandlerRegistry.h"
#include "core/frame/FrameConsole.h"
#include "core/frame/FrameHost.h"
#include "core/frame/FrameView.h"
#include "core/frame/PageScaleConstraints.h"
#include "core/frame/PageScaleConstraintsSet.h"
#include "core/frame/RemoteFrame.h"
#include "core/frame/RemoteFrameView.h"
#include "core/frame/Settings.h"
#include "core/frame/VisualViewport.h"
#include "core/html/HTMLMediaElement.h"
#include "core/inspector/ConsoleMessageStorage.h"
#include "core/inspector/InspectorInstrumentation.h"
#include "core/layout/TextAutosizer.h"
#include "core/page/AutoscrollController.h"
#include "core/page/ChromeClient.h"
#include "core/page/ContextMenuController.h"
#include "core/page/DragController.h"
#include "core/page/FocusController.h"
#include "core/page/PointerLockController.h"
#include "core/page/ScopedPageSuspender.h"
#include "core/page/ValidationMessageClient.h"
#include "core/page/scrolling/OverscrollController.h"
#include "core/page/scrolling/ScrollingCoordinator.h"
#include "core/page/scrolling/TopDocumentRootScrollerController.h"
#include "core/paint/PaintLayer.h"
#include "platform/WebFrameScheduler.h"
#include "platform/graphics/GraphicsLayer.h"
#include "platform/loader/fetch/ResourceFetcher.h"
#include "platform/plugins/PluginData.h"
#include "public/platform/Platform.h"

namespace blink {

// Set of all live pages; includes internal Page objects that are
// not observable from scripts.
static Page::PageSet& allPages() {
  DEFINE_STATIC_LOCAL(Page::PageSet, pages, ());
  return pages;
}

Page::PageSet& Page::ordinaryPages() {
  DEFINE_STATIC_LOCAL(Page::PageSet, pages, ());
  return pages;
}

float deviceScaleFactorDeprecated(LocalFrame* frame) {
  if (!frame)
    return 1;
  Page* page = frame->page();
  if (!page)
    return 1;
  return page->deviceScaleFactorDeprecated();
}

Page* Page::createOrdinary(PageClients& pageClients) {
  Page* page = create(pageClients);
  ordinaryPages().insert(page);
  if (ScopedPageSuspender::isActive())
    page->setSuspended(true);
  return page;
}

Page::Page(PageClients& pageClients)
    : SettingsDelegate(Settings::create()),
      m_animator(PageAnimator::create(*this)),
      m_autoscrollController(AutoscrollController::create(*this)),
      m_chromeClient(pageClients.chromeClient),
      m_dragCaret(DragCaret::create()),
      m_dragController(DragController::create(this)),
      m_focusController(FocusController::create(this)),
      m_contextMenuController(
          ContextMenuController::create(this, pageClients.contextMenuClient)),
      m_pageScaleConstraintsSet(PageScaleConstraintsSet::create()),
      m_pointerLockController(PointerLockController::create(this)),
      m_browserControls(BrowserControls::create(*this)),
      m_consoleMessageStorage(new ConsoleMessageStorage()),
      m_eventHandlerRegistry(new EventHandlerRegistry(*this)),
      m_globalRootScrollerController(
          TopDocumentRootScrollerController::create(*this)),
      m_visualViewport(VisualViewport::create(*this)),
      m_overscrollController(
          OverscrollController::create(visualViewport(), chromeClient())),
      m_mainFrame(nullptr),
      m_editorClient(pageClients.editorClient),
      m_spellCheckerClient(pageClients.spellCheckerClient),
      m_useCounter(pageClients.chromeClient &&
                           pageClients.chromeClient->isSVGImageChromeClient()
                       ? UseCounter::SVGImageContext
                       : UseCounter::DefaultContext),
      m_openedByDOM(false),
      m_tabKeyCyclesThroughElements(true),
      m_suspended(false),
      m_deviceScaleFactor(1),
      m_visibilityState(PageVisibilityStateVisible),
      m_isCursorVisible(true),
      m_subframeCount(0),
      m_frameHost(FrameHost::create(*this)) {
  ASSERT(m_editorClient);

  ASSERT(!allPages().contains(this));
  allPages().insert(this);
}

Page::~Page() {
  // willBeDestroyed() must be called before Page destruction.
  ASSERT(!m_mainFrame);
}

void Page::closeSoon() {
  // Make sure this Page can no longer be found by JS.
  m_isClosing = true;

  // TODO(dcheng): Try to remove this in a followup, it's not obviously needed.
  if (m_mainFrame->isLocalFrame())
    toLocalFrame(m_mainFrame)->loader().stopAllLoaders();

  chromeClient().closeWindowSoon();
}

ViewportDescription Page::viewportDescription() const {
  return mainFrame() && mainFrame()->isLocalFrame() &&
                 deprecatedLocalMainFrame()->document()
             ? deprecatedLocalMainFrame()->document()->viewportDescription()
             : ViewportDescription();
}

ScrollingCoordinator* Page::scrollingCoordinator() {
  if (!m_scrollingCoordinator && m_settings->getAcceleratedCompositingEnabled())
    m_scrollingCoordinator = ScrollingCoordinator::create(this);

  return m_scrollingCoordinator.get();
}

PageScaleConstraintsSet& Page::pageScaleConstraintsSet() {
  return *m_pageScaleConstraintsSet;
}

const PageScaleConstraintsSet& Page::pageScaleConstraintsSet() const {
  return *m_pageScaleConstraintsSet;
}

BrowserControls& Page::browserControls() {
  return *m_browserControls;
}

const BrowserControls& Page::browserControls() const {
  return *m_browserControls;
}

ConsoleMessageStorage& Page::consoleMessageStorage() {
  return *m_consoleMessageStorage;
}

const ConsoleMessageStorage& Page::consoleMessageStorage() const {
  return *m_consoleMessageStorage;
}

EventHandlerRegistry& Page::eventHandlerRegistry() {
  return *m_eventHandlerRegistry;
}

const EventHandlerRegistry& Page::eventHandlerRegistry() const {
  return *m_eventHandlerRegistry;
}

TopDocumentRootScrollerController& Page::globalRootScrollerController() const {
  return *m_globalRootScrollerController;
}

VisualViewport& Page::visualViewport() {
  return *m_visualViewport;
}

const VisualViewport& Page::visualViewport() const {
  return *m_visualViewport;
}

OverscrollController& Page::overscrollController() {
  return *m_overscrollController;
}

const OverscrollController& Page::overscrollController() const {
  return *m_overscrollController;
}

ClientRectList* Page::nonFastScrollableRects(const LocalFrame* frame) {
  DisableCompositingQueryAsserts disabler;
  if (ScrollingCoordinator* scrollingCoordinator =
          this->scrollingCoordinator()) {
    // Hits in compositing/iframes/iframe-composited-scrolling.html
    scrollingCoordinator->updateAfterCompositingChangeIfNeeded();
  }

  GraphicsLayer* layer =
      frame->view()->layoutViewportScrollableArea()->layerForScrolling();
  if (!layer)
    return ClientRectList::create();
  return ClientRectList::create(
      layer->platformLayer()->nonFastScrollableRegion());
}

void Page::setMainFrame(Frame* mainFrame) {
  // Should only be called during initialization or swaps between local and
  // remote frames.
  // FIXME: Unfortunately we can't assert on this at the moment, because this
  // is called in the base constructor for both LocalFrame and RemoteFrame,
  // when the vtables for the derived classes have not yet been setup.
  m_mainFrame = mainFrame;
}

void Page::willUnloadDocument(const Document& document) {
  if (m_validationMessageClient)
    m_validationMessageClient->willUnloadDocument(document);
}

void Page::documentDetached(Document* document) {
  m_pointerLockController->documentDetached(document);
  m_contextMenuController->documentDetached(document);
  if (m_validationMessageClient)
    m_validationMessageClient->documentDetached(*document);
  m_hostsUsingFeatures.documentDetached(*document);
}

bool Page::openedByDOM() const {
  return m_openedByDOM;
}

void Page::setOpenedByDOM() {
  m_openedByDOM = true;
}

void Page::platformColorsChanged() {
  for (const Page* page : allPages())
    for (Frame* frame = page->mainFrame(); frame;
         frame = frame->tree().traverseNext()) {
      if (frame->isLocalFrame())
        toLocalFrame(frame)->document()->platformColorsChanged();
    }
}

void Page::setNeedsRecalcStyleInAllFrames() {
  for (Frame* frame = mainFrame(); frame;
       frame = frame->tree().traverseNext()) {
    if (frame->isLocalFrame())
      toLocalFrame(frame)->document()->setNeedsStyleRecalc(
          SubtreeStyleChange,
          StyleChangeReasonForTracing::create(StyleChangeReason::Settings));
  }
}

void Page::refreshPlugins() {
  PluginData::refreshBrowserSidePluginCache();

  for (const Page* page : allPages()) {
    // Clear out the page's plugin data.
    if (page->m_pluginData)
      page->m_pluginData = nullptr;
  }
}

PluginData* Page::pluginData(SecurityOrigin* mainFrameOrigin) const {
  if (!m_pluginData ||
      !mainFrameOrigin->isSameSchemeHostPort(m_pluginData->origin()))
    m_pluginData = PluginData::create(mainFrameOrigin);
  return m_pluginData.get();
}

void Page::setValidationMessageClient(ValidationMessageClient* client) {
  m_validationMessageClient = client;
}

void Page::setSuspended(bool suspended) {
  if (suspended == m_suspended)
    return;

  m_suspended = suspended;
  for (Frame* frame = mainFrame(); frame;
       frame = frame->tree().traverseNext()) {
    if (!frame->isLocalFrame())
      continue;
    LocalFrame* localFrame = toLocalFrame(frame);
    localFrame->loader().setDefersLoading(suspended);
    localFrame->frameScheduler()->setSuspended(suspended);
  }
}

void Page::setDefaultPageScaleLimits(float minScale, float maxScale) {
  PageScaleConstraints newDefaults =
      pageScaleConstraintsSet().defaultConstraints();
  newDefaults.minimumScale = minScale;
  newDefaults.maximumScale = maxScale;

  if (newDefaults == pageScaleConstraintsSet().defaultConstraints())
    return;

  pageScaleConstraintsSet().setDefaultConstraints(newDefaults);
  pageScaleConstraintsSet().computeFinalConstraints();
  pageScaleConstraintsSet().setNeedsReset(true);

  if (!mainFrame() || !mainFrame()->isLocalFrame())
    return;

  FrameView* rootView = deprecatedLocalMainFrame()->view();

  if (!rootView)
    return;

  rootView->setNeedsLayout();
}

void Page::setUserAgentPageScaleConstraints(
    const PageScaleConstraints& newConstraints) {
  if (newConstraints == pageScaleConstraintsSet().userAgentConstraints())
    return;

  pageScaleConstraintsSet().setUserAgentConstraints(newConstraints);

  if (!mainFrame() || !mainFrame()->isLocalFrame())
    return;

  FrameView* rootView = deprecatedLocalMainFrame()->view();

  if (!rootView)
    return;

  rootView->setNeedsLayout();
}

void Page::setPageScaleFactor(float scale) {
  visualViewport().setScale(scale);
}

float Page::pageScaleFactor() const {
  return visualViewport().scale();
}

void Page::setDeviceScaleFactorDeprecated(float scaleFactor) {
  if (m_deviceScaleFactor == scaleFactor)
    return;

  m_deviceScaleFactor = scaleFactor;

  if (mainFrame() && mainFrame()->isLocalFrame())
    deprecatedLocalMainFrame()->deviceScaleFactorChanged();
}

void Page::allVisitedStateChanged(bool invalidateVisitedLinkHashes) {
  for (const Page* page : ordinaryPages()) {
    for (Frame* frame = page->m_mainFrame; frame;
         frame = frame->tree().traverseNext()) {
      if (frame->isLocalFrame())
        toLocalFrame(frame)
            ->document()
            ->visitedLinkState()
            .invalidateStyleForAllLinks(invalidateVisitedLinkHashes);
    }
  }
}

void Page::visitedStateChanged(LinkHash linkHash) {
  for (const Page* page : ordinaryPages()) {
    for (Frame* frame = page->m_mainFrame; frame;
         frame = frame->tree().traverseNext()) {
      if (frame->isLocalFrame())
        toLocalFrame(frame)
            ->document()
            ->visitedLinkState()
            .invalidateStyleForLink(linkHash);
    }
  }
}

void Page::setVisibilityState(PageVisibilityState visibilityState,
                              bool isInitialState) {
  if (m_visibilityState == visibilityState)
    return;
  m_visibilityState = visibilityState;

  if (!isInitialState)
    notifyPageVisibilityChanged();

  if (!isInitialState && m_mainFrame)
    m_mainFrame->didChangeVisibilityState();
}

PageVisibilityState Page::visibilityState() const {
  return m_visibilityState;
}

bool Page::isPageVisible() const {
  return visibilityState() == PageVisibilityStateVisible;
}

bool Page::isCursorVisible() const {
  return m_isCursorVisible;
}

#if DCHECK_IS_ON()
void checkFrameCountConsistency(int expectedFrameCount, Frame* frame) {
  DCHECK_GE(expectedFrameCount, 0);

  int actualFrameCount = 0;
  for (; frame; frame = frame->tree().traverseNext())
    ++actualFrameCount;

  DCHECK_EQ(expectedFrameCount, actualFrameCount);
}
#endif

int Page::subframeCount() const {
#if DCHECK_IS_ON()
  checkFrameCountConsistency(m_subframeCount + 1, mainFrame());
#endif
  return m_subframeCount;
}

void Page::settingsChanged(SettingsDelegate::ChangeType changeType) {
  switch (changeType) {
    case SettingsDelegate::StyleChange:
      setNeedsRecalcStyleInAllFrames();
      break;
    case SettingsDelegate::ViewportDescriptionChange:
      if (mainFrame() && mainFrame()->isLocalFrame()) {
        deprecatedLocalMainFrame()->document()->updateViewportDescription();
        // The text autosizer has dependencies on the viewport.
        if (TextAutosizer* textAutosizer =
                deprecatedLocalMainFrame()->document()->textAutosizer())
          textAutosizer->updatePageInfoInAllFrames();
      }
      break;
    case SettingsDelegate::DNSPrefetchingChange:
      for (Frame* frame = mainFrame(); frame;
           frame = frame->tree().traverseNext()) {
        if (frame->isLocalFrame())
          toLocalFrame(frame)->document()->initDNSPrefetch();
      }
      break;
    case SettingsDelegate::ImageLoadingChange:
      for (Frame* frame = mainFrame(); frame;
           frame = frame->tree().traverseNext()) {
        if (frame->isLocalFrame()) {
          toLocalFrame(frame)->document()->fetcher()->setImagesEnabled(
              settings().getImagesEnabled());
          toLocalFrame(frame)->document()->fetcher()->setAutoLoadImages(
              settings().getLoadsImagesAutomatically());
        }
      }
      break;
    case SettingsDelegate::TextAutosizingChange:
      if (!mainFrame() || !mainFrame()->isLocalFrame())
        break;
      if (TextAutosizer* textAutosizer =
              deprecatedLocalMainFrame()->document()->textAutosizer())
        textAutosizer->updatePageInfoInAllFrames();
      break;
    case SettingsDelegate::FontFamilyChange:
      for (Frame* frame = mainFrame(); frame;
           frame = frame->tree().traverseNext()) {
        if (frame->isLocalFrame())
          toLocalFrame(frame)
              ->document()
              ->styleEngine()
              .updateGenericFontFamilySettings();
      }
      break;
    case SettingsDelegate::AcceleratedCompositingChange:
      updateAcceleratedCompositingSettings();
      break;
    case SettingsDelegate::MediaQueryChange:
      for (Frame* frame = mainFrame(); frame;
           frame = frame->tree().traverseNext()) {
        if (frame->isLocalFrame())
          toLocalFrame(frame)->document()->mediaQueryAffectingValueChanged();
      }
      break;
    case SettingsDelegate::AccessibilityStateChange:
      if (!mainFrame() || !mainFrame()->isLocalFrame())
        break;
      deprecatedLocalMainFrame()
          ->document()
          ->axObjectCacheOwner()
          .clearAXObjectCache();
      break;
    case SettingsDelegate::ViewportRuleChange: {
      if (!mainFrame() || !mainFrame()->isLocalFrame())
        break;
      if (Document* doc = toLocalFrame(mainFrame())->document())
        doc->styleEngine().viewportRulesChanged();
    } break;
    case SettingsDelegate::TextTrackKindUserPreferenceChange:
      for (Frame* frame = mainFrame(); frame;
           frame = frame->tree().traverseNext()) {
        if (frame->isLocalFrame()) {
          Document* doc = toLocalFrame(frame)->document();
          if (doc)
            HTMLMediaElement::setTextTrackKindUserPreferenceForAllMediaElements(
                doc);
        }
      }
      break;
    case SettingsDelegate::DOMWorldsChange: {
      if (!settings().getForceMainWorldInitialization())
        break;
      for (Frame* frame = mainFrame(); frame;
           frame = frame->tree().traverseNext()) {
        if (!frame->isLocalFrame())
          continue;
        LocalFrame* localFrame = toLocalFrame(frame);
        if (localFrame->loader()
                .stateMachine()
                ->committedFirstRealDocumentLoad()) {
          // Forcibly instantiate WindowProxy.
          localFrame->script().windowProxy(DOMWrapperWorld::mainWorld());
        }
      }
    } break;
    case SettingsDelegate::MediaControlsChange:
      for (Frame* frame = mainFrame(); frame;
           frame = frame->tree().traverseNext()) {
        if (!frame->isLocalFrame())
          continue;
        Document* doc = toLocalFrame(frame)->document();
        if (doc)
          HTMLMediaElement::onMediaControlsEnabledChange(doc);
      }
      break;
  }
}

void Page::updateAcceleratedCompositingSettings() {
  for (Frame* frame = mainFrame(); frame;
       frame = frame->tree().traverseNext()) {
    if (!frame->isLocalFrame())
      continue;
    if (FrameView* view = toLocalFrame(frame)->view())
      view->updateAcceleratedCompositingSettings();
  }
}

void Page::didCommitLoad(LocalFrame* frame) {
  if (m_mainFrame == frame) {
    KURL url;
    if (frame->document())
      url = frame->document()->url();

    // TODO(rbyers): Most of this doesn't appear to take into account that each
    // SVGImage gets it's own Page instance.
    consoleMessageStorage().clear();
    useCounter().didCommitLoad(url);
    deprecation().clearSuppression();
    visualViewport().sendUMAMetrics();

    // Need to reset visual viewport position here since before commit load we
    // would update the previous history item, Page::didCommitLoad is called
    // after a new history item is created in FrameLoader.
    // See crbug.com/642279
    visualViewport().setScrollOffset(ScrollOffset(), ProgrammaticScroll);
    m_hostsUsingFeatures.updateMeasurementsAndClear();
  }
}

void Page::acceptLanguagesChanged() {
  HeapVector<Member<LocalFrame>> frames;

  // Even though we don't fire an event from here, the LocalDOMWindow's will
  // fire an event so we keep the frames alive until we are done.
  for (Frame* frame = mainFrame(); frame;
       frame = frame->tree().traverseNext()) {
    if (frame->isLocalFrame())
      frames.push_back(toLocalFrame(frame));
  }

  for (unsigned i = 0; i < frames.size(); ++i)
    frames[i]->domWindow()->acceptLanguagesChanged();
}

DEFINE_TRACE(Page) {
  visitor->trace(m_animator);
  visitor->trace(m_autoscrollController);
  visitor->trace(m_chromeClient);
  visitor->trace(m_dragCaret);
  visitor->trace(m_dragController);
  visitor->trace(m_focusController);
  visitor->trace(m_contextMenuController);
  visitor->trace(m_pointerLockController);
  visitor->trace(m_scrollingCoordinator);
  visitor->trace(m_browserControls);
  visitor->trace(m_consoleMessageStorage);
  visitor->trace(m_eventHandlerRegistry);
  visitor->trace(m_globalRootScrollerController);
  visitor->trace(m_visualViewport);
  visitor->trace(m_overscrollController);
  visitor->trace(m_mainFrame);
  visitor->trace(m_validationMessageClient);
  visitor->trace(m_useCounter);
  visitor->trace(m_frameHost);
  Supplementable<Page>::trace(visitor);
  PageVisibilityNotifier::trace(visitor);
}

void Page::layerTreeViewInitialized(WebLayerTreeView& layerTreeView,
                                    FrameView* view) {
  if (scrollingCoordinator())
    scrollingCoordinator()->layerTreeViewInitialized(layerTreeView, view);
}

void Page::willCloseLayerTreeView(WebLayerTreeView& layerTreeView,
                                  FrameView* view) {
  if (m_scrollingCoordinator)
    m_scrollingCoordinator->willCloseLayerTreeView(layerTreeView, view);
}

void Page::willBeDestroyed() {
  Frame* mainFrame = m_mainFrame;

  mainFrame->detach(FrameDetachType::Remove);

  ASSERT(allPages().contains(this));
  allPages().erase(this);
  ordinaryPages().erase(this);

  if (m_scrollingCoordinator)
    m_scrollingCoordinator->willBeDestroyed();

  chromeClient().chromeDestroyed();
  if (m_validationMessageClient)
    m_validationMessageClient->willBeDestroyed();
  m_mainFrame = nullptr;

  PageVisibilityNotifier::notifyContextDestroyed();
}

Page::PageClients::PageClients()
    : chromeClient(nullptr),
      contextMenuClient(nullptr),
      editorClient(nullptr),
      spellCheckerClient(nullptr) {}

Page::PageClients::~PageClients() {}

template class CORE_TEMPLATE_EXPORT Supplement<Page>;

}  // namespace blink