LCOV - code coverage report
Current view: top level - gfx/layers - LayersLogging.h (source / functions) Hit Total Coverage
Test: output.info Lines: 0 70 0.0 %
Date: 2017-07-14 16:53:18 Functions: 0 31 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
       5             : 
       6             : #ifndef GFX_LAYERSLOGGING_H
       7             : #define GFX_LAYERSLOGGING_H
       8             : 
       9             : #include "FrameMetrics.h"               // for FrameMetrics, etc
      10             : #include "mozilla/gfx/Matrix.h"         // for Matrix4x4
      11             : #include "mozilla/gfx/Point.h"          // for IntSize, etc
      12             : #include "mozilla/gfx/TiledRegion.h"    // for TiledRegion
      13             : #include "mozilla/gfx/Types.h"          // for SamplingFilter, SurfaceFormat
      14             : #include "mozilla/layers/CompositorTypes.h"  // for TextureFlags
      15             : #include "mozilla/layers/WebRenderLayersLogging.h"
      16             : #include "nsAString.h"
      17             : #include "nsPrintfCString.h"            // for nsPrintfCString
      18             : #include "nsRegion.h"                   // for nsRegion, nsIntRegion
      19             : #include "nscore.h"                     // for nsACString, etc
      20             : 
      21             : struct WrColor;
      22             : struct WrRect;
      23             : struct WrSize;
      24             : 
      25             : namespace mozilla {
      26             : namespace gfx {
      27             : template <class units, class F> struct RectTyped;
      28             : } // namespace gfx
      29             : 
      30             : enum class ImageFormat;
      31             : 
      32             : namespace layers {
      33             : 
      34             : void
      35             : AppendToString(std::stringstream& aStream, const void* p,
      36             :                const char* pfx="", const char* sfx="");
      37             : 
      38             : void
      39             : AppendToString(std::stringstream& aStream, FrameMetrics::ViewID n,
      40             :                const char* pfx="", const char* sfx="");
      41             : 
      42             : void
      43             : AppendToString(std::stringstream& aStream, const gfx::Color& c,
      44             :                const char* pfx="", const char* sfx="");
      45             : 
      46             : void
      47             : AppendToString(std::stringstream& aStream, const nsPoint& p,
      48             :                const char* pfx="", const char* sfx="");
      49             : 
      50             : void
      51             : AppendToString(std::stringstream& aStream, const nsRect& r,
      52             :                const char* pfx="", const char* sfx="");
      53             : 
      54             : template<class T>
      55             : void
      56           0 : AppendToString(std::stringstream& aStream, const mozilla::gfx::PointTyped<T>& p,
      57             :                const char* pfx="", const char* sfx="")
      58             : {
      59           0 :   aStream << pfx << p << sfx;
      60           0 : }
      61             : 
      62             : template<class T>
      63             : void
      64           0 : AppendToString(std::stringstream& aStream, const mozilla::gfx::IntPointTyped<T>& p,
      65             :                const char* pfx="", const char* sfx="")
      66             : {
      67           0 :   aStream << pfx << p << sfx;
      68           0 : }
      69             : 
      70             : template<class T>
      71             : void
      72           0 : AppendToString(std::stringstream& aStream, const mozilla::gfx::RectTyped<T>& r,
      73             :                const char* pfx="", const char* sfx="")
      74             : {
      75           0 :   aStream << pfx;
      76           0 :   aStream << nsPrintfCString(
      77             :     "(x=%f, y=%f, w=%f, h=%f)",
      78           0 :     r.x, r.y, r.width, r.height).get();
      79           0 :   aStream << sfx;
      80           0 : }
      81             : 
      82             : template<class T>
      83             : void
      84           0 : AppendToString(std::stringstream& aStream, const mozilla::gfx::IntRectTyped<T>& r,
      85             :                const char* pfx="", const char* sfx="")
      86             : {
      87           0 :   aStream << pfx;
      88           0 :   aStream << nsPrintfCString(
      89             :     "(x=%d, y=%d, w=%d, h=%d)",
      90           0 :     r.x, r.y, r.width, r.height).get();
      91           0 :   aStream << sfx;
      92           0 : }
      93             : 
      94             : void
      95             : AppendToString(std::stringstream& aStream, const WrColor& c,
      96             :                const char* pfx="", const char* sfx="");
      97             : 
      98             : void
      99             : AppendToString(std::stringstream& aStream, const WrRect& r,
     100             :                const char* pfx="", const char* sfx="");
     101             : 
     102             : void
     103             : AppendToString(std::stringstream& aStream, const WrSize& s,
     104             :                const char* pfx="", const char* sfx="");
     105             : 
     106             : void
     107             : AppendToString(std::stringstream& aStream, const nsRegion& r,
     108             :                const char* pfx="", const char* sfx="");
     109             : 
     110             : void
     111             : AppendToString(std::stringstream& aStream, const nsIntRegion& r,
     112             :                const char* pfx="", const char* sfx="");
     113             : 
     114             : template <typename units>
     115             : void
     116           0 : AppendToString(std::stringstream& aStream, const mozilla::gfx::IntRegionTyped<units>& r,
     117             :                const char* pfx="", const char* sfx="")
     118             : {
     119           0 :   aStream << pfx;
     120             : 
     121           0 :   aStream << "< ";
     122           0 :   for (auto iter = r.RectIter(); !iter.Done(); iter.Next()) {
     123           0 :     AppendToString(aStream, iter.Get());
     124           0 :     aStream << "; ";
     125             :   }
     126           0 :   aStream << ">";
     127             : 
     128           0 :   aStream << sfx;
     129           0 : }
     130             : 
     131             : template <typename T>
     132             : void
     133             : AppendToString(std::stringstream& aStream, const mozilla::gfx::TiledRegion<T>& r,
     134             :                const char* pfx="", const char* sfx="")
     135             : {
     136             :   aStream << pfx;
     137             :   AppendToString(aStream, r.GetRegion());
     138             :   aStream << " (bounds=";
     139             :   AppendToString(aStream, r.GetBounds());
     140             :   aStream << ", covers=" << r.CoversBounds() << ")" << sfx;
     141             : }
     142             : 
     143             : void
     144             : AppendToString(std::stringstream& aStream, const EventRegions& e,
     145             :                const char* pfx="", const char* sfx="");
     146             : 
     147             : void
     148             : AppendToString(std::stringstream& aStream, const ScrollMetadata& m,
     149             :                const char* pfx="", const char* sfx="");
     150             : 
     151             : void
     152             : AppendToString(std::stringstream& aStream, const FrameMetrics& m,
     153             :                const char* pfx="", const char* sfx="", bool detailed = false);
     154             : 
     155             : void
     156             : AppendToString(std::stringstream& aStream, const ScrollableLayerGuid& s,
     157             :                const char* pfx="", const char* sfx="");
     158             : 
     159             : void
     160             : AppendToString(std::stringstream& aStream, const ZoomConstraints& z,
     161             :                const char* pfx="", const char* sfx="");
     162             : 
     163             : template<class T>
     164             : void
     165           0 : AppendToString(std::stringstream& aStream, const mozilla::gfx::MarginTyped<T>& m,
     166             :                const char* pfx="", const char* sfx="")
     167             : {
     168           0 :   aStream << pfx;
     169           0 :   aStream << nsPrintfCString(
     170             :     "(l=%f, t=%f, r=%f, b=%f)",
     171           0 :     m.left, m.top, m.right, m.bottom).get();
     172           0 :   aStream << sfx;
     173           0 : }
     174             : 
     175             : template<class T>
     176             : void
     177           0 : AppendToString(std::stringstream& aStream, const mozilla::gfx::SizeTyped<T>& sz,
     178             :                const char* pfx="", const char* sfx="")
     179             : {
     180           0 :   aStream << pfx;
     181           0 :   aStream << nsPrintfCString(
     182             :     "(w=%f, h=%f)",
     183           0 :     sz.width, sz.height).get();
     184           0 :   aStream << sfx;
     185           0 : }
     186             : 
     187             : template<class T>
     188             : void
     189           0 : AppendToString(std::stringstream& aStream, const mozilla::gfx::IntSizeTyped<T>& sz,
     190             :                const char* pfx="", const char* sfx="")
     191             : {
     192           0 :   aStream << pfx;
     193           0 :   aStream << nsPrintfCString(
     194             :     "(w=%d, h=%d)",
     195           0 :     sz.width, sz.height).get();
     196           0 :   aStream << sfx;
     197           0 : }
     198             : 
     199             : template<class src, class dst>
     200             : void
     201           0 : AppendToString(std::stringstream& aStream, const mozilla::gfx::ScaleFactors2D<src, dst>& scale,
     202             :                const char* pfx="", const char* sfx="")
     203             : {
     204           0 :   aStream << pfx;
     205           0 :   std::streamsize oldPrecision = aStream.precision(3);
     206           0 :   if (scale.AreScalesSame()) {
     207           0 :     aStream << scale.xScale;
     208             :   } else {
     209           0 :     aStream << '(' << scale.xScale << ',' << scale.yScale << ')';
     210             :   }
     211           0 :   aStream.precision(oldPrecision);
     212           0 :   aStream << sfx;
     213           0 : }
     214             : 
     215             : void
     216             : AppendToString(std::stringstream& aStream, const mozilla::gfx::Matrix& m,
     217             :                const char* pfx="", const char* sfx="");
     218             : 
     219             : template<class SourceUnits, class TargetUnits>
     220             : void
     221           0 : AppendToString(std::stringstream& aStream, const mozilla::gfx::Matrix4x4Typed<SourceUnits, TargetUnits>& m,
     222             :                const char* pfx="", const char* sfx="")
     223             : {
     224           0 :   if (m.Is2D()) {
     225           0 :     mozilla::gfx::Matrix matrix = m.As2D();
     226           0 :     AppendToString(aStream, matrix, pfx, sfx);
     227           0 :     return;
     228             :   }
     229             : 
     230           0 :   aStream << pfx;
     231           0 :   aStream << nsPrintfCString(
     232             :     "[ %g %g %g %g; %g %g %g %g; %g %g %g %g; %g %g %g %g; ]",
     233           0 :     m._11, m._12, m._13, m._14,
     234           0 :     m._21, m._22, m._23, m._24,
     235           0 :     m._31, m._32, m._33, m._34,
     236           0 :     m._41, m._42, m._43, m._44).get();
     237           0 :   aStream << sfx;
     238             : }
     239             : 
     240             : void
     241             : AppendToString(std::stringstream& aStream, const mozilla::gfx::Matrix5x4& m,
     242             :                const char* pfx="", const char* sfx="");
     243             : 
     244             : void
     245             : AppendToString(std::stringstream& aStream,
     246             :                const mozilla::gfx::SamplingFilter samplingFilter,
     247             :                const char* pfx="", const char* sfx="");
     248             : 
     249             : void
     250             : AppendToString(std::stringstream& aStream, mozilla::layers::TextureFlags flags,
     251             :                const char* pfx="", const char* sfx="");
     252             : 
     253             : void
     254             : AppendToString(std::stringstream& aStream, mozilla::gfx::SurfaceFormat format,
     255             :                const char* pfx="", const char* sfx="");
     256             : 
     257             : void
     258             : AppendToString(std::stringstream& aStream, gfx::SurfaceType format,
     259             :                const char* pfx="", const char* sfx="");
     260             : 
     261             : void
     262             : AppendToString(std::stringstream& aStream, ImageFormat format,
     263             :                const char* pfx="", const char* sfx="");
     264             : 
     265             : // Sometimes, you just want a string from a single value.
     266             : template <typename T>
     267             : std::string
     268           0 : Stringify(const T& obj)
     269             : {
     270           0 :   std::stringstream ss;
     271           0 :   AppendToString(ss, obj);
     272           0 :   return ss.str();
     273             : }
     274             : 
     275             : } // namespace layers
     276             : } // namespace mozilla
     277             : 
     278             : // versions of printf_stderr and fprintf_stderr that deal with line
     279             : // truncation on android by printing individual lines out of the
     280             : // stringstream as separate calls to logcat.
     281             : void print_stderr(std::stringstream& aStr);
     282             : void fprint_stderr(FILE* aFile, std::stringstream& aStr);
     283             : 
     284             : #endif /* GFX_LAYERSLOGGING_H */

Generated by: LCOV version 1.13