LCOV - code coverage report
Current view: top level - obj-x86_64-pc-linux-gnu/dist/include/mozilla/dom - APZTestDataBinding.h (source / functions) Hit Total Coverage
Test: output.info Lines: 0 22 0.0 %
Date: 2017-07-14 16:53:18 Functions: 0 10 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* THIS FILE IS AUTOGENERATED FROM APZTestData.webidl BY Codegen.py - DO NOT EDIT */
       2             : 
       3             : #ifndef mozilla_dom_APZTestDataBinding_h
       4             : #define mozilla_dom_APZTestDataBinding_h
       5             : 
       6             : #include "js/RootingAPI.h"
       7             : #include "jspubtd.h"
       8             : #include "mozilla/ErrorResult.h"
       9             : #include "mozilla/dom/BindingDeclarations.h"
      10             : #include "mozilla/dom/Nullable.h"
      11             : 
      12             : namespace mozilla {
      13             : namespace dom {
      14             : 
      15             : struct APZBucket;
      16             : struct APZBucketAtoms;
      17             : struct APZTestDataAtoms;
      18             : struct FrameUniformity;
      19             : struct FrameUniformityAtoms;
      20             : struct FrameUniformityResultsAtoms;
      21             : struct NativePropertyHooks;
      22             : class ProtoAndIfaceCache;
      23             : struct ScrollFrameData;
      24             : struct ScrollFrameDataAtoms;
      25             : struct ScrollFrameDataEntry;
      26             : struct ScrollFrameDataEntryAtoms;
      27             : 
      28             : } // namespace dom
      29             : } // namespace mozilla
      30             : 
      31             : namespace mozilla {
      32             : namespace dom {
      33             : 
      34           0 : struct FrameUniformity : public DictionaryBase
      35             : {
      36             :   MOZ_INIT_OUTSIDE_CTOR Optional<float> mFrameUniformity;
      37             :   MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mLayerAddress;
      38             : 
      39             :   FrameUniformity();
      40             : 
      41             :   explicit inline FrameUniformity(const FastDictionaryInitializer& )
      42             :   {
      43             :     // Do nothing here; this is used by our "Fast" subclass
      44             :   }
      45             : 
      46           0 :   explicit inline FrameUniformity(const FrameUniformity& aOther)
      47           0 :   {
      48           0 :     *this = aOther;
      49           0 :   }
      50             : 
      51             :   bool
      52             :   Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
      53             : 
      54             :   bool
      55             :   Init(const nsAString& aJSON);
      56             : 
      57             :   bool
      58             :   ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
      59             : 
      60             :   bool
      61             :   ToJSON(nsAString& aJSON) const;
      62             : 
      63             :   void
      64             :   TraceDictionary(JSTracer* trc);
      65             : 
      66             :   FrameUniformity&
      67             :   operator=(const FrameUniformity& aOther);
      68             : 
      69             : private:
      70             :   static bool
      71             :   InitIds(JSContext* cx, FrameUniformityAtoms* atomsCache);
      72             : };
      73             : 
      74             : namespace binding_detail {
      75             : struct FastFrameUniformity : public FrameUniformity
      76             : {
      77             :   inline FastFrameUniformity()
      78             :     : FrameUniformity(FastDictionaryInitializer())
      79             :   {
      80             :     // Doesn't matter what int we pass to the parent constructor
      81             :   }
      82             : };
      83             : } // namespace binding_detail
      84             : 
      85             : 
      86           0 : struct ScrollFrameDataEntry : public DictionaryBase
      87             : {
      88             :   MOZ_INIT_OUTSIDE_CTOR Optional<nsString> mKey;
      89             :   MOZ_INIT_OUTSIDE_CTOR Optional<nsString> mValue;
      90             : 
      91             :   ScrollFrameDataEntry();
      92             : 
      93             :   explicit inline ScrollFrameDataEntry(const FastDictionaryInitializer& )
      94             :   {
      95             :     // Do nothing here; this is used by our "Fast" subclass
      96             :   }
      97             : 
      98           0 :   explicit inline ScrollFrameDataEntry(const ScrollFrameDataEntry& aOther)
      99           0 :   {
     100           0 :     *this = aOther;
     101           0 :   }
     102             : 
     103             :   bool
     104             :   Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
     105             : 
     106             :   bool
     107             :   Init(const nsAString& aJSON);
     108             : 
     109             :   bool
     110             :   ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
     111             : 
     112             :   bool
     113             :   ToJSON(nsAString& aJSON) const;
     114             : 
     115             :   void
     116             :   TraceDictionary(JSTracer* trc);
     117             : 
     118             :   ScrollFrameDataEntry&
     119             :   operator=(const ScrollFrameDataEntry& aOther);
     120             : 
     121             : private:
     122             :   static bool
     123             :   InitIds(JSContext* cx, ScrollFrameDataEntryAtoms* atomsCache);
     124             : };
     125             : 
     126             : namespace binding_detail {
     127             : struct FastScrollFrameDataEntry : public ScrollFrameDataEntry
     128             : {
     129             :   inline FastScrollFrameDataEntry()
     130             :     : ScrollFrameDataEntry(FastDictionaryInitializer())
     131             :   {
     132             :     // Doesn't matter what int we pass to the parent constructor
     133             :   }
     134             : };
     135             : } // namespace binding_detail
     136             : 
     137             : 
     138           0 : struct FrameUniformityResults : public DictionaryBase
     139             : {
     140             :   MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<FrameUniformity>> mLayerUniformities;
     141             : 
     142             :   FrameUniformityResults();
     143             : 
     144             :   explicit inline FrameUniformityResults(const FastDictionaryInitializer& )
     145             :   {
     146             :     // Do nothing here; this is used by our "Fast" subclass
     147             :   }
     148             : 
     149             :   explicit inline FrameUniformityResults(const FrameUniformityResults& aOther)
     150             :   {
     151             :     *this = aOther;
     152             :   }
     153             : 
     154             :   bool
     155             :   Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
     156             : 
     157             :   bool
     158             :   Init(const nsAString& aJSON);
     159             : 
     160             :   bool
     161             :   ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
     162             : 
     163             :   bool
     164             :   ToJSON(nsAString& aJSON) const;
     165             : 
     166             :   void
     167             :   TraceDictionary(JSTracer* trc);
     168             : 
     169             :   FrameUniformityResults&
     170             :   operator=(const FrameUniformityResults& aOther);
     171             : 
     172             : private:
     173             :   static bool
     174             :   InitIds(JSContext* cx, FrameUniformityResultsAtoms* atomsCache);
     175             : };
     176             : 
     177             : namespace binding_detail {
     178             : struct FastFrameUniformityResults : public FrameUniformityResults
     179             : {
     180             :   inline FastFrameUniformityResults()
     181             :     : FrameUniformityResults(FastDictionaryInitializer())
     182             :   {
     183             :     // Doesn't matter what int we pass to the parent constructor
     184             :   }
     185             : };
     186             : } // namespace binding_detail
     187             : 
     188             : 
     189           0 : struct ScrollFrameData : public DictionaryBase
     190             : {
     191             :   MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<ScrollFrameDataEntry>> mEntries;
     192             :   MOZ_INIT_OUTSIDE_CTOR Optional<uint64_t> mScrollId;
     193             : 
     194             :   ScrollFrameData();
     195             : 
     196             :   explicit inline ScrollFrameData(const FastDictionaryInitializer& )
     197             :   {
     198             :     // Do nothing here; this is used by our "Fast" subclass
     199             :   }
     200             : 
     201           0 :   explicit inline ScrollFrameData(const ScrollFrameData& aOther)
     202           0 :   {
     203           0 :     *this = aOther;
     204           0 :   }
     205             : 
     206             :   bool
     207             :   Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
     208             : 
     209             :   bool
     210             :   Init(const nsAString& aJSON);
     211             : 
     212             :   bool
     213             :   ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
     214             : 
     215             :   bool
     216             :   ToJSON(nsAString& aJSON) const;
     217             : 
     218             :   void
     219             :   TraceDictionary(JSTracer* trc);
     220             : 
     221             :   ScrollFrameData&
     222             :   operator=(const ScrollFrameData& aOther);
     223             : 
     224             : private:
     225             :   static bool
     226             :   InitIds(JSContext* cx, ScrollFrameDataAtoms* atomsCache);
     227             : };
     228             : 
     229             : namespace binding_detail {
     230             : struct FastScrollFrameData : public ScrollFrameData
     231             : {
     232             :   inline FastScrollFrameData()
     233             :     : ScrollFrameData(FastDictionaryInitializer())
     234             :   {
     235             :     // Doesn't matter what int we pass to the parent constructor
     236             :   }
     237             : };
     238             : } // namespace binding_detail
     239             : 
     240             : 
     241           0 : struct APZBucket : public DictionaryBase
     242             : {
     243             :   MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<ScrollFrameData>> mScrollFrames;
     244             :   MOZ_INIT_OUTSIDE_CTOR Optional<uint32_t> mSequenceNumber;
     245             : 
     246             :   APZBucket();
     247             : 
     248             :   explicit inline APZBucket(const FastDictionaryInitializer& )
     249             :   {
     250             :     // Do nothing here; this is used by our "Fast" subclass
     251             :   }
     252             : 
     253           0 :   explicit inline APZBucket(const APZBucket& aOther)
     254           0 :   {
     255           0 :     *this = aOther;
     256           0 :   }
     257             : 
     258             :   bool
     259             :   Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
     260             : 
     261             :   bool
     262             :   Init(const nsAString& aJSON);
     263             : 
     264             :   bool
     265             :   ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
     266             : 
     267             :   bool
     268             :   ToJSON(nsAString& aJSON) const;
     269             : 
     270             :   void
     271             :   TraceDictionary(JSTracer* trc);
     272             : 
     273             :   APZBucket&
     274             :   operator=(const APZBucket& aOther);
     275             : 
     276             : private:
     277             :   static bool
     278             :   InitIds(JSContext* cx, APZBucketAtoms* atomsCache);
     279             : };
     280             : 
     281             : namespace binding_detail {
     282             : struct FastAPZBucket : public APZBucket
     283             : {
     284             :   inline FastAPZBucket()
     285             :     : APZBucket(FastDictionaryInitializer())
     286             :   {
     287             :     // Doesn't matter what int we pass to the parent constructor
     288             :   }
     289             : };
     290             : } // namespace binding_detail
     291             : 
     292             : 
     293           0 : struct APZTestData : public DictionaryBase
     294             : {
     295             :   MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<APZBucket>> mPaints;
     296             :   MOZ_INIT_OUTSIDE_CTOR Optional<Sequence<APZBucket>> mRepaintRequests;
     297             : 
     298             :   APZTestData();
     299             : 
     300             :   explicit inline APZTestData(const FastDictionaryInitializer& )
     301             :   {
     302             :     // Do nothing here; this is used by our "Fast" subclass
     303             :   }
     304             : 
     305             :   explicit inline APZTestData(const APZTestData& aOther)
     306             :   {
     307             :     *this = aOther;
     308             :   }
     309             : 
     310             :   bool
     311             :   Init(JSContext* cx, JS::Handle<JS::Value> val, const char* sourceDescription = "Value", bool passedToJSImpl = false);
     312             : 
     313             :   bool
     314             :   Init(const nsAString& aJSON);
     315             : 
     316             :   bool
     317             :   ToObjectInternal(JSContext* cx, JS::MutableHandle<JS::Value> rval) const;
     318             : 
     319             :   bool
     320             :   ToJSON(nsAString& aJSON) const;
     321             : 
     322             :   void
     323             :   TraceDictionary(JSTracer* trc);
     324             : 
     325             :   APZTestData&
     326             :   operator=(const APZTestData& aOther);
     327             : 
     328             : private:
     329             :   static bool
     330             :   InitIds(JSContext* cx, APZTestDataAtoms* atomsCache);
     331             : };
     332             : 
     333             : namespace binding_detail {
     334             : struct FastAPZTestData : public APZTestData
     335             : {
     336             :   inline FastAPZTestData()
     337             :     : APZTestData(FastDictionaryInitializer())
     338             :   {
     339             :     // Doesn't matter what int we pass to the parent constructor
     340             :   }
     341             : };
     342             : } // namespace binding_detail
     343             : 
     344             : 
     345             : } // namespace dom
     346             : } // namespace mozilla
     347             : 
     348             : #endif // mozilla_dom_APZTestDataBinding_h

Generated by: LCOV version 1.13