Change other usages of .size() to .empty() when applicable.

net/websockets/websocket_handshake_handler.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/websockets/websocket_handshake_handler.h"
 
 #include "base/md5.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "googleurl/src/gurl.h"
@@ skipping 156 matching lines @@
   original_length_ = input.size();
   return true;
 }
 
 size_t WebSocketHandshakeRequestHandler::original_length() const {
   return original_length_;
 }
 
 void WebSocketHandshakeRequestHandler::AppendHeaderIfMissing(
     const std::string& name, const std::string& value) {
-  DCHECK(headers_.size() > 0);
+  DCHECK(!headers_.empty());
   HttpUtil::AppendHeaderIfMissing(name.c_str(), value, &headers_);
 }
 
 void WebSocketHandshakeRequestHandler::RemoveHeaders(
     const char* const headers_to_remove[],
     size_t headers_to_remove_len) {
-  DCHECK(headers_.size() > 0);
+  DCHECK(!headers_.empty());
   headers_ = FilterHeaders(
       headers_, headers_to_remove, headers_to_remove_len);
 }
 
 HttpRequestInfo WebSocketHandshakeRequestHandler::GetRequestInfo(
     const GURL& url, std::string* challenge) {
   HttpRequestInfo request_info;
   request_info.url = url;
   base::StringPiece method = status_line_.data();
   size_t method_end = base::StringPiece(
@@ skipping 65 matching lines @@
 
   challenge->clear();
   GetKeyNumber(key1, challenge);
   GetKeyNumber(key2, challenge);
   challenge->append(key3_);
 
   return true;
 }
 
 std::string WebSocketHandshakeRequestHandler::GetRawRequest() {
-  DCHECK(status_line_.size() > 0);
-  DCHECK(headers_.size() > 0);
+  DCHECK(!status_line_.empty());
+  DCHECK(!headers_.empty());
   DCHECK_EQ(kRequestKey3Size, key3_.size());
   std::string raw_request = status_line_ + headers_ + "\r\n" + key3_;
   raw_length_ = raw_request.size();
   return raw_request;
 }
 
 size_t WebSocketHandshakeRequestHandler::raw_length() const {
   DCHECK_GT(raw_length_, 0);
   return raw_length_;
 }
 
 WebSocketHandshakeResponseHandler::WebSocketHandshakeResponseHandler()
     : original_header_length_(0) {
 }
 
 WebSocketHandshakeResponseHandler::~WebSocketHandshakeResponseHandler() {}
 
 size_t WebSocketHandshakeResponseHandler::ParseRawResponse(
     const char* data, int length) {
   DCHECK_GT(length, 0);
   if (HasResponse()) {
-    DCHECK(status_line_.size() > 0);
-    DCHECK(headers_.size() > 0);
+    DCHECK(!status_line_.empty());
+    DCHECK(!headers_.empty());
     DCHECK_EQ(kResponseKeySize, key_.size());
     return 0;
   }
 
   size_t old_original_length = original_.size();
 
   original_.append(data, length);
   // TODO(ukai): fail fast when response gives wrong status code.
   original_header_length_ = HttpUtil::LocateEndOfHeaders(
       original_.data(), original_.size(), 0);
@@ skipping 85 matching lines @@
 
   return ParseRawResponse(response_message.data(),
                           response_message.size()) == response_message.size();
 }
 
 void WebSocketHandshakeResponseHandler::GetHeaders(
     const char* const headers_to_get[],
     size_t headers_to_get_len,
     std::vector<std::string>* values) {
   DCHECK(HasResponse());
-  DCHECK(status_line_.size() > 0);
-  DCHECK(headers_.size() > 0);
+  DCHECK(!status_line_.empty());
+  DCHECK(!headers_.empty());
   DCHECK_EQ(kResponseKeySize, key_.size());
 
   FetchHeaders(headers_, headers_to_get, headers_to_get_len, values);
 }
 
 void WebSocketHandshakeResponseHandler::RemoveHeaders(
     const char* const headers_to_remove[],
     size_t headers_to_remove_len) {
   DCHECK(HasResponse());
-  DCHECK(status_line_.size() > 0);
-  DCHECK(headers_.size() > 0);
+  DCHECK(!status_line_.empty());
+  DCHECK(!headers_.empty());
   DCHECK_EQ(kResponseKeySize, key_.size());
 
   headers_ = FilterHeaders(headers_, headers_to_remove, headers_to_remove_len);
 }
 
 std::string WebSocketHandshakeResponseHandler::GetRawResponse() const {
   DCHECK(HasResponse());
   return std::string(original_.data(),
                      original_header_length_ + kResponseKeySize);
 }
 
 std::string WebSocketHandshakeResponseHandler::GetResponse() {
   DCHECK(HasResponse());
-  DCHECK(status_line_.size() > 0);
+  DCHECK(!status_line_.empty());
   // headers_ might be empty for wrong response from server.
   DCHECK_EQ(kResponseKeySize, key_.size());
 
   return status_line_ + headers_ + header_separator_ + key_;
 }
 
 }  // namespace net