[2D Canvas] Send GPU resources into hibernation when page is not visible

third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridge.h

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * 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 22 matching lines @@
 #include "public/platform/WebExternalTextureLayerClient.h"
 #include "public/platform/WebExternalTextureMailbox.h"
 #include "public/platform/WebThread.h"
 #include "third_party/khronos/GLES2/gl2.h"
 #include "third_party/skia/include/core/SkImage.h"
 #include "wtf/Allocator.h"
 #include "wtf/Deque.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/RefCounted.h"
 #include "wtf/RefPtr.h"
+#include "wtf/WeakPtr.h"
 
 class SkPictureRecorder;
 
 namespace blink {
 
+class Canvas2DLayerBridgeHistogramLogger;
 class Canvas2DLayerBridgeTest;
 class ImageBuffer;
 class WebGraphicsContext3D;
 class WebGraphicsContext3DProvider;
 class SharedContextRateLimiter;
 
 class PLATFORM_EXPORT Canvas2DLayerBridge : public WebExternalTextureLayerClient, public WebThread::TaskObserver, public RefCounted<Canvas2DLayerBridge> {
     WTF_MAKE_NONCOPYABLE(Canvas2DLayerBridge);
 public:
     enum AccelerationMode {
@@ skipping 25 matching lines @@
     void setIsHidden(bool);
     void setImageBuffer(ImageBuffer*);
     void didDraw(const FloatRect&);
     bool writePixels(const SkImageInfo&, const void* pixels, size_t rowBytes, int x, int y);
     void flush();
     void flushGpu();
     void prepareSurfaceForPaintingIfNeeded();
     bool isHidden() { return m_isHidden; }
 
     void beginDestruction();
+    void hibernate();
+    bool isHibernating() const { return m_hibernationImage; }
 
     PassRefPtr<SkImage> newImageSnapshot(AccelerationHint);
 
+    // The values of the enum entries must not change because they are used for
+    // usage metrics histograms. New values can be added to the end.
+    enum HibernationEvent {
+        HibernationScheduled = 0,
+        HibernationAbortedDueToDestructionWhileHibernatePending = 1,
+        HibernationAbortedDueToPendingDestruction = 2,
+        HibernationAbortedDueToVisibilityChange = 3,
+        HibernationAbortedDueGpuContextLoss = 4,
+        HibernationAbortedDueToSwitchToUnacceleratedRendering = 5,
+        HibernationAbortedDueToAllocationFailure = 6,
+        HibernationEndedNormally = 7,
+        HibernationEndedWithSwitchToBackgroundRendering = 8,
+        HibernationEndedWithFallbackToSW = 9,
+        HibernationEndedWithTeardown = 10,
+
+        HibernationEventCount = 11,
+    };
+
+    class PLATFORM_EXPORT Logger {
+    public:
+        virtual void reportHibernationEvent(HibernationEvent);
+        virtual void didStartHibernating() { }
+        virtual ~Logger() { }
+    };
+
+    void setLoggerForTesting(PassOwnPtr<Logger>);
+
 private:
     Canvas2DLayerBridge(PassOwnPtr<WebGraphicsContext3DProvider>, const IntSize&, int msaaSampleCount, OpacityMode, AccelerationMode);
     WebGraphicsContext3D* context();
     void startRecording();
     void skipQueuedDrawCommands();
     void flushRecordingOnly();
     void unregisterTaskObserver();
 
     // WebThread::TaskOberver implementation
     void willProcessTask() override;
     void didProcessTask() override;
 
     SkSurface* getOrCreateSurface(AccelerationHint = PreferAcceleration);
     bool shouldAccelerate(AccelerationHint) const;
 
     OwnPtr<SkPictureRecorder> m_recorder;
     RefPtr<SkSurface> m_surface;
+    RefPtr<SkImage> m_hibernationImage;
     int m_initialSurfaceSaveCount;
     OwnPtr<WebExternalTextureLayer> m_layer;
     OwnPtr<WebGraphicsContext3DProvider> m_contextProvider;
     OwnPtr<SharedContextRateLimiter> m_rateLimiter;
+    OwnPtr<Logger> m_logger;
+    WeakPtrFactory<Canvas2DLayerBridge> m_weakPtrFactory;
     ImageBuffer* m_imageBuffer;
     int m_msaaSampleCount;
     size_t m_bytesAllocated;
     bool m_haveRecordedDrawCommands;
     bool m_destructionInProgress;
     SkFilterQuality m_filterQuality;
     bool m_isHidden;
     bool m_isDeferralEnabled;
     bool m_isRegisteredTaskObserver;
     bool m_renderingTaskCompletedForCurrentFrame;
+    bool m_softwareRenderingWhileHidden;
 
     friend class Canvas2DLayerBridgeTest;
 
     struct MailboxInfo {
         DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
         WebExternalTextureMailbox m_mailbox;
         RefPtr<SkImage> m_image;
         RefPtr<Canvas2DLayerBridge> m_parentLayerBridge;
 
         MailboxInfo(const MailboxInfo&);
@@ skipping 12 matching lines @@
     GLenum m_lastFilter;
     AccelerationMode m_accelerationMode;
     OpacityMode m_opacityMode;
     IntSize m_size;
     int m_recordingPixelCount;
 };
 
 } // namespace blink
 
 #endif