Whitespace fix: remove whitespace from the end of lines.

src/core/SkMemory_stdlib.cpp

 /* libs/corecg/SkMemory_stdlib.cpp
 **
 ** Copyright 2006, The Android Open Source Project
 **
-** Licensed under the Apache License, Version 2.0 (the "License"); 
-** you may not use this file except in compliance with the License. 
-** You may obtain a copy of the License at 
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
 **
-**     http://www.apache.org/licenses/LICENSE-2.0 
+**     http://www.apache.org/licenses/LICENSE-2.0
 **
-** Unless required by applicable law or agreed to in writing, software 
-** distributed under the License is distributed on an "AS IS" BASIS, 
-** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
-** See the License for the specific language governing permissions and 
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
 ** limitations under the License.
 */
 
 #include "SkTypes.h"
 #include <stdio.h>
 #include <stdlib.h>
 
 #ifdef SK_DEBUG
     #define SK_TAG_BLOCKS
     // #define SK_TRACK_ALLOC  // enable to see a printf for every alloc/free
@@ skipping 26 matching lines @@
     SkBlockHeader* fNext;
 #ifdef SK_CHECK_TAGS
     SkBlockHeader** fTop; // set to verify in debugger that block was alloc'd / freed with same gHeader
     SkBlockHeader* fPrevious; // set to see in debugger previous block when corruption happens
 #endif
     size_t fSize;
     char fHeader[sizeof(kBlockHeaderTag)];
     // data goes here. The offset to this point must be a multiple of 8
     char fTrailer[sizeof(kBlockTrailerTag)];
 
-    void* add(size_t realSize) 
+    void* add(size_t realSize)
     {
         SkAutoMutexAcquire  ac(get_block_mutex());
         InMutexValidate();
         fNext = gHeader;
 #ifdef SK_CHECK_TAGS
         fTop = &gHeader;
         fPrevious = NULL;
         if (fNext != NULL)
             fNext->fPrevious = this;
 #endif
         gHeader = this;
         fSize = realSize;
         memcpy(fHeader, kBlockHeaderTag, sizeof(kBlockHeaderTag));
         void* result = fTrailer;
         void* trailer = (char*)result + realSize;
         memcpy(trailer, kBlockTrailerTag, sizeof(kBlockTrailerTag));
         return result;
     }
-    
+
     static void Dump()
     {
         SkAutoMutexAcquire  ac(get_block_mutex());
         InMutexValidate();
         SkBlockHeader* header = gHeader;
         int count = 0;
         size_t size = 0;
         while (header != NULL) {
             char scratch[256];
             char* pos = scratch;
@@ skipping 38 matching lines @@
                 *findPtr = fNext;
                 break;
             }
             findPtr = &find->fNext;
         } while (true);
         InMutexValidate();
         SkASSERT(memcmp(fHeader, kBlockHeaderTag, sizeof(kBlockHeaderTag)) == 0);
         const char* trailer = fTrailer + fSize;
         SkASSERT(memcmp(trailer, kBlockTrailerTag, sizeof(kBlockTrailerTag)) == 0);
     }
-    
+
     static void Validate()
     {
         SkAutoMutexAcquire  ac(get_block_mutex());
         InMutexValidate();
     }
 
 private:
     static void InMutexValidate()
     {
         SkBlockHeader* header = gHeader;
@@ skipping 44 matching lines @@
     if (addr != NULL) {
         SkBlockHeader* header = (SkBlockHeader*)
             ((char*)addr - SK_OFFSETOF(SkBlockHeader, fTrailer));
         header->remove();
 #ifdef SK_TRACK_ALLOC
         printf("sk_realloc_throw %p oldSize=%zd\n", addr, header->fSize);
 #endif
         addr = header;
     }
     size_t realSize = size;
-    if (size) 
+    if (size)
         size += sizeof(SkBlockHeader);
 #endif
 
     void* p = realloc(addr, size);
     if (size == 0)
     {
         ValidateHeap();
         return p;
     }
 
@@ skipping 12 matching lines @@
     ValidateHeap();
     return p;
 }
 
 void sk_free(void* p)
 {
     if (p)
     {
         ValidateHeap();
 #ifdef SK_TAG_BLOCKS
-        SkBlockHeader* header = (SkBlockHeader*) 
+        SkBlockHeader* header = (SkBlockHeader*)
             ((char*)p - SK_OFFSETOF(SkBlockHeader, fTrailer));
         header->remove();
 #ifdef SK_TRACK_ALLOC
         printf("sk_free %p size=%zd\n", p, header->fSize);
 #endif
         size_t size = header->fSize + sizeof(SkBlockHeader);
         memset(header, kDeleteFill, size);
         p = header;
 #endif
         ValidateHeap();
         free(p);
         ValidateHeap();
     }
 }
 
 void* sk_malloc_flags(size_t size, unsigned flags)
 {
     ValidateHeap();
 #ifdef SK_TAG_BLOCKS
     size_t realSize = size;
     size += sizeof(SkBlockHeader);
 #endif
-    
+
     void* p = malloc(size);
     if (p == NULL)
     {
         if (flags & SK_MALLOC_THROW)
             sk_throw();
     }
 #ifdef SK_TAG_BLOCKS
     else
     {
         SkBlockHeader* header = (SkBlockHeader*) p;
         p = header->add(realSize);
         memset(p, kByteFill, realSize);
 #ifdef SK_TRACK_ALLOC
         printf("sk_malloc_flags %p size=%zd\n", p, realSize);
 #endif
     }
 #endif
     ValidateHeap();
     return p;
 }