Move webrtc/{base => rtc_base}

webrtc/rtc_base/cryptstring.h

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
-#ifndef _WEBRTC_BASE_CRYPTSTRING_H_
-#define _WEBRTC_BASE_CRYPTSTRING_H_
+#ifndef WEBRTC_RTC_BASE_CRYPTSTRING_H_
+#define WEBRTC_RTC_BASE_CRYPTSTRING_H_
 
 #include <string.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 namespace rtc {
 
 class CryptStringImpl {
@@ skipping 44 matching lines @@
 // Used for constructing strings where a password is involved and we
 // need to ensure that we zero memory afterwards
 class FormatCryptString {
 public:
   FormatCryptString() {
     storage_ = new char[32];
     capacity_ = 32;
     length_ = 0;
     storage_[0] = 0;
   }
-  
+
   void Append(const std::string & text) {
     Append(text.data(), text.length());
   }
 
   void Append(const char * data, size_t length) {
     EnsureStorage(length_ + length + 1);
     memcpy(storage_ + length_, data, length);
     length_ += length;
     storage_[length_] = '\0';
   }
-  
+
   void Append(const CryptString * password) {
     size_t len = password->GetLength();
     EnsureStorage(length_ + len + 1);
     password->CopyTo(storage_ + length_, true);
     length_ += len;
   }
 
   size_t GetLength() {
     return length_;
   }
@@ skipping 15 matching lines @@
     for (;;) {
       capacity_ *= 2;
       if (capacity_ >= n)
         break;
     }
 
     storage_ = new char[capacity_];
 
     if (old_capacity) {
       memcpy(storage_, old_storage, length_);
-    
+
       // zero memory in a way that an optimizer won't optimize it out
       old_storage[0] = 0;
       for (size_t i = 1; i < old_capacity; i++) {
         old_storage[i] = old_storage[i - 1];
       }
       delete[] old_storage;
     }
-  }  
+  }
 
   ~FormatCryptString() {
     if (capacity_) {
       storage_[0] = 0;
       for (size_t i = 1; i < capacity_; i++) {
         storage_[i] = storage_[i - 1];
       }
     }
     delete[] storage_;
   }
@@ skipping 14 matching lines @@
   std::string UrlEncode() const override;
   CryptStringImpl* Copy() const override;
   void CopyRawTo(std::vector<unsigned char>* dest) const override;
 
  private:
   std::string password_;
 };
 
 }
 
-#endif  // _WEBRTC_BASE_CRYPTSTRING_H_
+#endif  // WEBRTC_RTC_BASE_CRYPTSTRING_H_