reflow comments in modules/[fetch,indexeddb]

third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.cpp

 /*
  * Copyright (C) 2010 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 101 matching lines @@
 }
 
 KURL DOMFileSystemBase::createFileSystemURL(const EntryBase* entry) const {
   return createFileSystemURL(entry->fullPath());
 }
 
 KURL DOMFileSystemBase::createFileSystemURL(const String& fullPath) const {
   ASSERT(DOMFilePath::isAbsolute(fullPath));
 
   if (type() == FileSystemTypeExternal) {
-    // For external filesystem originString could be different from what we have in m_filesystemRootURL.
+    // For external filesystem originString could be different from what we have
+    // in m_filesystemRootURL.
     StringBuilder result;
     result.append("filesystem:");
     result.append(getSecurityOrigin()->toString());
     result.append('/');
     result.append(externalPathPrefix);
     result.append(m_filesystemRootURL.path());
     // Remove the extra leading slash.
     result.append(encodeWithURLEscapeSequences(fullPath.substring(1)));
     return KURL(ParsedURLString, result.toString());
   }
 
-  // For regular types we can just append the entry's fullPath to the m_filesystemRootURL that should look like 'filesystem:<origin>/<typePrefix>'.
+  // For regular types we can just append the entry's fullPath to the
+  // m_filesystemRootURL that should look like
+  // 'filesystem:<origin>/<typePrefix>'.
   ASSERT(!m_filesystemRootURL.isEmpty());
   KURL url = m_filesystemRootURL;
   // Remove the extra leading slash.
   url.setPath(url.path() + encodeWithURLEscapeSequences(fullPath.substring(1)));
   return url;
 }
 
 bool DOMFileSystemBase::pathToAbsolutePath(FileSystemType type,
                                            const EntryBase* base,
                                            String path,
@@ skipping 26 matching lines @@
     return true;
   }
 
   return false;
 }
 
 File* DOMFileSystemBase::createFile(const FileMetadata& metadata,
                                     const KURL& fileSystemURL,
                                     FileSystemType type,
                                     const String name) {
-  // For regular filesystem types (temporary or persistent), we should not cache file metadata as it could change File semantics.
-  // For other filesystem types (which could be platform-specific ones), there's a chance that the files are on remote filesystem.
-  // If the port has returned metadata just pass it to File constructor (so we may cache the metadata).
+  // For regular filesystem types (temporary or persistent), we should not cache
+  // file metadata as it could change File semantics.  For other filesystem
+  // types (which could be platform-specific ones), there's a chance that the
+  // files are on remote filesystem.  If the port has returned metadata just
+  // pass it to File constructor (so we may cache the metadata).
   // FIXME: We should use the snapshot metadata for all files.
   // https://www.w3.org/Bugs/Public/show_bug.cgi?id=17746
   if (type == FileSystemTypeTemporary || type == FileSystemTypePersistent)
     return File::createForFileSystemFile(metadata.platformPath, name);
 
   const File::UserVisibility userVisibility = (type == FileSystemTypeExternal)
                                                   ? File::IsUserVisible
                                                   : File::IsNotUserVisible;
 
   if (!metadata.platformPath.isEmpty()) {
-    // If the platformPath in the returned metadata is given, we create a File object for the snapshot path.
+    // If the platformPath in the returned metadata is given, we create a File
+    // object for the snapshot path.
     return File::createForFileSystemFile(name, metadata, userVisibility);
   } else {
     // Otherwise we create a File object for the fileSystemURL.
     return File::createForFileSystemFile(fileSystemURL, metadata,
                                          userVisibility);
   }
 }
 
 void DOMFileSystemBase::getMetadata(const EntryBase* entry,
                                     MetadataCallback* successCallback,
@@ skipping 18 matching lines @@
 
   if (!parent || !parent->isDirectory())
     return false;
 
   if (!newName.isEmpty() && !DOMFilePath::isValidName(newName))
     return false;
 
   const bool isSameFileSystem =
       (*source->filesystem() == *parent->filesystem());
 
-  // It is an error to try to copy or move an entry inside itself at any depth if it is a directory.
+  // It is an error to try to copy or move an entry inside itself at any depth
+  // if it is a directory.
   if (source->isDirectory() && isSameFileSystem &&
       DOMFilePath::isParentOf(source->fullPath(), parent->fullPath()))
     return false;
 
-  // It is an error to copy or move an entry into its parent if a name different from its current one isn't provided.
+  // It is an error to copy or move an entry into its parent if a name different
+  // from its current one isn't provided.
   if (isSameFileSystem && (newName.isEmpty() || source->name() == newName) &&
       DOMFilePath::getDirectory(source->fullPath()) == parent->fullPath())
     return false;
 
   destinationPath = parent->fullPath();
   if (!newName.isEmpty())
     destinationPath = DOMFilePath::append(destinationPath, newName);
   else
     destinationPath = DOMFilePath::append(destinationPath, source->name());
 
@@ skipping 198 matching lines @@
                                      std::move(callbacks));
 }
 
 bool DOMFileSystemBase::waitForAdditionalResult(int callbacksId) {
   if (!fileSystem())
     return false;
   return fileSystem()->waitForAdditionalResult(callbacksId);
 }
 
 }  // namespace blink