LCOV - app.info - gfx/skia/src/core/SkBuffer.cpp

LCOV - code coverage report
| Current view: | directory - gfx/skia/src/core - SkBuffer.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 35 | 0 | 0.0 %
| Date: | 2012-07-07 | Functions: | 6 | 0 | 0.0 %

           1                 :
           2                 : /*
           3                 :  * Copyright 2006 The Android Open Source Project
           4                 :  *
           5                 :  * Use of this source code is governed by a BSD-style license that can be
           6                 :  * found in the LICENSE file.
           7                 :  */
           8                 :
           9                 :
          10                 : #include "SkBuffer.h"
          11                 :
          12                 : ////////////////////////////////////////////////////////////////////////////////////////
          13                 :
          14               0 : void SkRBuffer::readNoSizeCheck(void* buffer, size_t size)
          15                 : {
          16               0 :     SkASSERT((fData != 0 && fStop == 0) || fPos + size <= fStop);
          17               0 :     if (buffer)
          18               0 :         memcpy(buffer, fPos, size);
          19               0 :     fPos += size;
          20               0 : }
          21                 :
          22               0 : const void* SkRBuffer::skip(size_t size)
          23                 : {
          24               0 :     const void* result = fPos;
          25               0 :     readNoSizeCheck(NULL, size);
          26               0 :     return result;
          27                 : }
          28                 :
          29               0 : size_t SkRBuffer::skipToAlign4()
          30                 : {
          31               0 :     size_t pos = this->pos();
          32               0 :     size_t n = SkAlign4(pos) - pos;
          33               0 :     fPos += n;
          34               0 :     return n;
          35                 : }
          36                 :
          37               0 : void* SkWBuffer::skip(size_t size)
          38                 : {
          39               0 :     void* result = fPos;
          40               0 :     writeNoSizeCheck(NULL, size);
          41               0 :     return fData == NULL ? NULL : result;
          42                 : }
          43                 :
          44               0 : void SkWBuffer::writeNoSizeCheck(const void* buffer, size_t size)
          45                 : {
          46               0 :     SkASSERT(fData == 0 || fStop == 0 || fPos + size <= fStop);
          47               0 :     if (fData && buffer)
          48               0 :         memcpy(fPos, buffer, size);
          49               0 :     fPos += size;
          50               0 : }
          51                 :
          52               0 : size_t SkWBuffer::padToAlign4()
          53                 : {
          54               0 :     size_t pos = this->pos();
          55               0 :     size_t n = SkAlign4(pos) - pos;
          56                 :
          57               0 :     if (n && fData)
          58                 :     {
          59               0 :         char* p = fPos;
          60               0 :         char* stop = p + n;
          61               0 :         do {
          62               0 :             *p++ = 0;
          63                 :         } while (p < stop);
          64                 :     }
          65               0 :     fPos += n;
          66               0 :     return n;
          67                 : }
          68                 :
          69                 : #if 0
          70                 : #ifdef SK_DEBUG
          71                 :     static void AssertBuffer32(const void* buffer)
          72                 :     {
          73                 :         SkASSERT(buffer);
          74                 :         SkASSERT(((size_t)buffer & 3) == 0);
          75                 :     }
          76                 : #else
          77                 :     #define AssertBuffer32(buffer)
          78                 : #endif
          79                 :
          80                 : void* sk_buffer_write_int32(void* buffer, int32_t value)
          81                 : {
          82                 :     AssertBuffer32(buffer);
          83                 :     *(int32_t*)buffer = value;
          84                 :     return (char*)buffer + sizeof(int32_t);
          85                 : }
          86                 :
          87                 : void* sk_buffer_write_int32(void* buffer, const int32_t values[], int count)
          88                 : {
          89                 :     AssertBuffer32(buffer);
          90                 :     SkASSERT(count >= 0);
          91                 :
          92                 :     memcpy((int32_t*)buffer, values, count * sizeof(int32_t));
          93                 :     return (char*)buffer + count * sizeof(int32_t);
          94                 : }
          95                 :
          96                 : const void* sk_buffer_read_int32(const void* buffer, int32_t* value)
          97                 : {
          98                 :     AssertBuffer32(buffer);
          99                 :     if (value)
         100                 :         *value = *(const int32_t*)buffer;
         101                 :     return (const char*)buffer + sizeof(int32_t);
         102                 : }
         103                 :
         104                 : const void* sk_buffer_read_int32(const void* buffer, int32_t values[], int count)
         105                 : {
         106                 :     AssertBuffer32(buffer);
         107                 :     SkASSERT(count >= 0);
         108                 :
         109                 :     if (values)
         110                 :         memcpy(values, (const int32_t*)buffer, count * sizeof(int32_t));
         111                 :     return (const char*)buffer + count * sizeof(int32_t);
         112                 : }
         113                 :
         114                 : void* sk_buffer_write_ptr(void* buffer, void* ptr)
         115                 : {
         116                 :     AssertBuffer32(buffer);
         117                 :     *(void**)buffer = ptr;
         118                 :     return (char*)buffer + sizeof(void*);
         119                 : }
         120                 :
         121                 : const void* sk_buffer_read_ptr(const void* buffer, void** ptr)
         122                 : {
         123                 :     AssertBuffer32(buffer);
         124                 :     if (ptr)
         125                 :         *ptr = *(void**)buffer;
         126                 :     return (const char*)buffer + sizeof(void*);
         127                 : }
         128                 :
         129                 : #endif

Generated by: LCOV version 1.7