reflow comments in platform/{transforms,weborigin}

third_party/WebKit/Source/platform/weborigin/KURL.cpp

 /*
  * Copyright (C) 2004, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2012 Research In Motion Limited. All rights reserved.
  * Copyright (C) 2008, 2009, 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
@@ skipping 37 matching lines @@
 static void assertProtocolIsGood(const char* protocol) {
 #if ENABLE(ASSERT)
   const char* p = protocol;
   while (*p) {
     ASSERT(*p > ' ' && *p < 0x7F && !(*p >= 'A' && *p <= 'Z'));
     ++p;
   }
 #endif
 }
 
-// Note: You must ensure that |spec| is a valid canonicalized URL before calling this function.
+// Note: You must ensure that |spec| is a valid canonicalized URL before calling
+// this function.
 static const char* asURLChar8Subtle(const String& spec) {
   ASSERT(spec.is8Bit());
-  // characters8 really return characters in Latin-1, but because we canonicalize
-  // URL strings, we know that everything before the fragment identifier will
-  // actually be ASCII, which means this cast is safe as long as you don't look
-  // at the fragment component.
+  // characters8 really return characters in Latin-1, but because we
+  // canonicalize URL strings, we know that everything before the fragment
+  // identifier will actually be ASCII, which means this cast is safe as long as
+  // you don't look at the fragment component.
   return reinterpret_cast<const char*>(spec.characters8());
 }
 
 // Returns the characters for the given string, or a pointer to a static empty
 // string if the input string is null. This will always ensure we have a non-
 // null character pointer since ReplaceComponents has special meaning for null.
 static const char* charactersOrEmpty(const StringUTF8Adaptor& string) {
   static const char zero = 0;
   return string.data() ? string.data() : &zero;
 }
@@ skipping 10 matching lines @@
 static bool isUnicodeEncoding(const WTF::TextEncoding* encoding) {
   return encoding->encodingForFormSubmission() == UTF8Encoding();
 }
 
 namespace {
 
 class KURLCharsetConverter final : public url::CharsetConverter {
   DISALLOW_NEW();
 
  public:
-  // The encoding parameter may be 0, but in this case the object must not be called.
+  // The encoding parameter may be 0, but in this case the object must not be
+  // called.
   explicit KURLCharsetConverter(const WTF::TextEncoding* encoding)
       : m_encoding(encoding) {}
 
   void ConvertFromUTF16(const base::char16* input,
                         int inputLength,
                         url::CanonOutput* output) override {
     CString encoded = m_encoding->encode(
         String(input, inputLength), WTF::URLEncodedEntitiesForUnencodables);
     output->Append(encoded.data(), static_cast<int>(encoded.length()));
   }
@@ skipping 231 matching lines @@
 }
 
 String KURL::host() const {
   return componentString(m_parsed.host);
 }
 
 // Returns 0 when there is no port.
 //
 // We treat URL's with out-of-range port numbers as invalid URLs, and they will
 // be rejected by the canonicalizer. KURL.cpp will allow them in parsing, but
-// return invalidPortNumber from this port() function, so we mirror that behavior here.
+// return invalidPortNumber from this port() function, so we mirror that
+// behavior here.
 unsigned short KURL::port() const {
   if (!m_isValid || m_parsed.port.len <= 0)
     return 0;
   ASSERT(!m_string.isNull());
   int port = m_string.is8Bit()
                  ? url::ParsePort(asURLChar8Subtle(m_string), m_parsed.port)
                  : url::ParsePort(m_string.characters16(), m_parsed.port);
   ASSERT(port != url::PORT_UNSPECIFIED);  // Checked port.len <= 0 before.
 
   if (port == url::PORT_INVALID ||
@@ skipping 416 matching lines @@
                         const char* protocol) {
   const CHAR* begin = spec + scheme.begin;
   const CHAR* end = begin + scheme.len;
 
   while (begin != end && *protocol) {
     ASSERT(toASCIILower(*protocol) == *protocol);
     if (toASCIILower(*begin++) != *protocol++)
       return false;
   }
 
-  // Both strings are equal (ignoring case) if and only if all of the characters were equal,
-  // and the end of both has been reached.
+  // Both strings are equal (ignoring case) if and only if all of the characters
+  // were equal, and the end of both has been reached.
   return begin == end && !*protocol;
 }
 
 template <typename CHAR>
 bool checkIfProtocolIsInHTTPFamily(const url::Component& scheme,
                                    const CHAR* spec) {
   if (scheme.len == 4)
     return internalProtocolIs(scheme, spec, "http");
   if (scheme.len == 5)
     return internalProtocolIs(scheme, spec, "https");
@@ skipping 14 matching lines @@
   m_protocolIsInHTTPFamily =
       m_string.is8Bit() ? checkIfProtocolIsInHTTPFamily(m_parsed.scheme,
                                                         m_string.characters8())
                         : checkIfProtocolIsInHTTPFamily(
                               m_parsed.scheme, m_string.characters16());
 }
 
 bool KURL::protocolIs(const char* protocol) const {
   assertProtocolIsGood(protocol);
 
-  // JavaScript URLs are "valid" and should be executed even if KURL decides they are invalid.
-  // The free function protocolIsJavaScript() should be used instead.
-  // FIXME: Chromium code needs to be fixed for this assert to be enabled. ASSERT(strcmp(protocol, "javascript"));
+  // JavaScript URLs are "valid" and should be executed even if KURL decides
+  // they are invalid.  The free function protocolIsJavaScript() should be used
+  // instead.
+  // FIXME: Chromium code needs to be fixed for this assert to be enabled.
+  // ASSERT(strcmp(protocol, "javascript"));
 
   if (m_string.isNull() || m_parsed.scheme.len <= 0)
     return *protocol == '\0';
 
   return m_string.is8Bit()
              ? internalProtocolIs(m_parsed.scheme, m_string.characters8(),
                                   protocol)
              : internalProtocolIs(m_parsed.scheme, m_string.characters16(),
                                   protocol);
 }
@@ skipping 30 matching lines @@
   m_parsed = newParsed;
   m_string = AtomicString::fromUTF8(output.data(), output.length());
 }
 
 bool KURL::isSafeToSendToAnotherThread() const {
   return m_string.isSafeToSendToAnotherThread() &&
          (!m_innerURL || m_innerURL->isSafeToSendToAnotherThread());
 }
 
 }  // namespace blink