cc: remove loseOutputSurface.

cc/layer_tree_host.cc

 // Copyright 2011 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 "cc/layer_tree_host.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 58 matching lines @@
 }
 
 LayerTreeHost::LayerTreeHost(LayerTreeHostClient* client, const LayerTreeSettings& settings)
     : m_animating(false)
     , m_needsFullTreeSync(true)
     , m_client(client)
     , m_commitNumber(0)
     , m_renderingStats()
     , m_rendererInitialized(false)
     , m_outputSurfaceLost(false)
-    , m_numTimesRecreateShouldFail(0)
     , m_numFailedRecreateAttempts(0)
     , m_settings(settings)
     , m_debugState(settings.initialDebugState)
     , m_deviceScaleFactor(1)
     , m_visible(true)
     , m_pageScaleFactor(1)
     , m_minPageScaleFactor(1)
     , m_maxPageScaleFactor(1)
     , m_triggerIdleUpdates(true)
     , m_backgroundColor(SK_ColorWHITE)
@@ skipping 79 matching lines @@
                                            std::min(m_settings.defaultTileSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
     m_settings.maxUntiledLayerSize = gfx::Size(std::min(m_settings.maxUntiledLayerSize.width(), m_proxy->rendererCapabilities().maxTextureSize),
                                                std::min(m_settings.maxUntiledLayerSize.height(), m_proxy->rendererCapabilities().maxTextureSize));
 }
 
 LayerTreeHost::RecreateResult LayerTreeHost::recreateOutputSurface()
 {
     TRACE_EVENT0("cc", "LayerTreeHost::recreateOutputSurface");
     DCHECK(m_outputSurfaceLost);
 
-    bool recreated = false;
-    if (!m_numTimesRecreateShouldFail)
-        recreated = m_proxy->recreateOutputSurface();
-    else
-        m_numTimesRecreateShouldFail--;
-
-    if (recreated) {
+    if (m_proxy->recreateOutputSurface()) {
         m_client->didRecreateOutputSurface(true);
         m_outputSurfaceLost = false;
         return RecreateSucceeded;
     }
 
     // Tolerate a certain number of recreation failures to work around races
     // in the output-surface-lost machinery.
     m_numFailedRecreateAttempts++;
     if (m_numFailedRecreateAttempts < 5) {
         // FIXME: The single thread does not self-schedule output surface
@@ skipping 326 matching lines @@
         return;
     m_visible = visible;
     m_proxy->setVisible(visible);
 }
 
 void LayerTreeHost::startPageScaleAnimation(gfx::Vector2d targetOffset, bool useAnchor, float scale, base::TimeDelta duration)
 {
     m_proxy->startPageScaleAnimation(targetOffset, useAnchor, scale, duration);
 }
 
-void LayerTreeHost::loseOutputSurface(int numTimes)
-{
-    TRACE_EVENT1("cc", "LayerTreeHost::loseCompositorOutputSurface", "numTimes", numTimes);
-    m_numTimesRecreateShouldFail = numTimes - 1;
-    m_proxy->loseOutputSurface();
-}
-
 PrioritizedResourceManager* LayerTreeHost::contentsTextureManager() const
 {
     return m_contentsTextureManager.get();
 }
 
 void LayerTreeHost::composite()
 {
     if (!m_proxy->hasImplThread())
         static_cast<SingleThreadProxy*>(m_proxy.get())->compositeImmediately();
     else
@@ skipping 343 matching lines @@
             else
                 layer->notifyAnimationFinished(wallClockTime.ToDoubleT());
         }
     }
 
     for (size_t childIndex = 0; childIndex < layer->children().size(); ++childIndex)
         setAnimationEventsRecursive(events, layer->children()[childIndex].get(), wallClockTime);
 }
 
 }  // namespace cc