Moved rtc::Base64 to base approved.

webrtc/base/base64.cc

 
 //*********************************************************************
 //* Base64 - a simple base64 encoder and decoder.
 //*
 //*     Copyright (c) 1999, Bob Withers - bwit@pobox.com
 //*
 //* This code may be freely used for any purpose, either personal
 //* or commercial, provided the authors copyright notice remains
 //* intact.
 //*
 //* Enhancements by Stanley Yamane:
 //*     o reverse lookup table for the decode function
 //*     o reserve string buffer space in advance
 //*
 //*********************************************************************
 
 #include "webrtc/base/base64.h"
 
 #include <string.h>
 
-#include "webrtc/base/common.h"
+#include "webrtc/base/checks.h"
 
 using std::vector;
 
 namespace rtc {
 
 static const char kPad = '=';
 static const unsigned char pd = 0xFD;  // Padding
 static const unsigned char sp = 0xFE;  // Whitespace
 static const unsigned char il = 0xFF;  // Illegal base64 character
 
@@ skipping 58 matching lines @@
 bool Base64::IsBase64Encoded(const std::string& str) {
   for (size_t i = 0; i < str.size(); ++i) {
     if (!IsBase64Char(str.at(i)))
       return false;
   }
   return true;
 }
 
 void Base64::EncodeFromArray(const void* data, size_t len,
                              std::string* result) {
-  ASSERT(NULL != result);
+  RTC_DCHECK(NULL != result);
   result->clear();
   result->resize(((len + 2) / 3) * 4);
   const unsigned char* byte_data = static_cast<const unsigned char*>(data);
 
   unsigned char c;
   size_t i = 0;
   size_t dest_ix = 0;
   while (i < len) {
     c = (byte_data[i] >> 2) & 0x3f;
     (*result)[dest_ix++] = Base64Table[c];
@@ skipping 88 matching lines @@
                              vector<char>* result, size_t* data_used) {
   return DecodeFromArrayTemplate<vector<char> >(data, len, flags, result,
                                                 data_used);
 }
 
 template<typename T>
 bool Base64::DecodeFromArrayTemplate(const char* data, size_t len,
                                      DecodeFlags flags, T* result,
                                      size_t* data_used)
 {
-  ASSERT(NULL != result);
-  ASSERT(flags <= (DO_PARSE_MASK | DO_PAD_MASK | DO_TERM_MASK));
+  RTC_DCHECK(NULL != result);
+  RTC_DCHECK(flags <= (DO_PARSE_MASK | DO_PAD_MASK | DO_TERM_MASK));
 
   const DecodeFlags parse_flags = flags & DO_PARSE_MASK;
   const DecodeFlags pad_flags   = flags & DO_PAD_MASK;
   const DecodeFlags term_flags  = flags & DO_TERM_MASK;
-  ASSERT(0 != parse_flags);
-  ASSERT(0 != pad_flags);
-  ASSERT(0 != term_flags);
+  RTC_DCHECK(0 != parse_flags);
+  RTC_DCHECK(0 != pad_flags);
+  RTC_DCHECK(0 != term_flags);
 
   result->clear();
   result->reserve(len);
 
   size_t dpos = 0;
   bool success = true, padded;
   unsigned char c, qbuf[4];
   while (dpos < len) {
     size_t qlen = GetNextQuantum(parse_flags, (DO_PAD_NO == pad_flags),
                                  data, len, &dpos, qbuf, &padded);
@@ skipping 23 matching lines @@
   if ((DO_TERM_BUFFER == term_flags) && (dpos != len)) {
     success = false;  // unused chars
   }
   if (data_used) {
     *data_used = dpos;
   }
   return success;
 }
 
 } // namespace rtc