reflow comments in core/events,core/fileapi

third_party/WebKit/Source/core/fileapi/File.cpp

 /*
  * Copyright (C) 2008 Apple 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 238 matching lines @@
   if (hasBackingFile() && getFileModificationTime(m_path, modificationTimeMS) &&
       isValidFileTime(modificationTimeMS))
     return modificationTimeMS;
 
   return currentTimeMS();
 }
 
 long long File::lastModified() const {
   double modifiedDate = lastModifiedMS();
 
-  // The getter should return the current time when the last modification time isn't known.
+  // The getter should return the current time when the last modification time
+  // isn't known.
   if (!isValidFileTime(modifiedDate))
     modifiedDate = currentTimeMS();
 
   // lastModified returns a number, not a Date instance,
   // http://dev.w3.org/2006/webapi/FileAPI/#file-attrs
   return floor(modifiedDate);
 }
 
 double File::lastModifiedDate() const {
   double modifiedDate = lastModifiedMS();
 
-  // The getter should return the current time when the last modification time isn't known.
+  // The getter should return the current time when the last modification time
+  // isn't known.
   if (!isValidFileTime(modifiedDate))
     modifiedDate = currentTimeMS();
 
   // lastModifiedDate returns a Date instance,
   // http://www.w3.org/TR/FileAPI/#dfn-lastModifiedDate
   return modifiedDate;
 }
 
 unsigned long long File::size() const {
   if (hasValidSnapshotMetadata())
     return m_snapshotSize;
 
-  // FIXME: JavaScript cannot represent sizes as large as unsigned long long, we need to
-  // come up with an exception to throw if file size is not representable.
+  // FIXME: JavaScript cannot represent sizes as large as unsigned long long, we
+  // need to come up with an exception to throw if file size is not
+  // representable.
   long long size;
   if (!hasBackingFile() || !getFileSize(m_path, size))
     return 0;
   return static_cast<unsigned long long>(size);
 }
 
 Blob* File::slice(long long start,
                   long long end,
                   const String& contentType,
                   ExceptionState& exceptionState) const {
   if (isClosed()) {
     exceptionState.throwDOMException(InvalidStateError,
                                      "File has been closed.");
     return nullptr;
   }
 
   if (!m_hasBackingFile)
     return Blob::slice(start, end, contentType, exceptionState);
 
-  // FIXME: This involves synchronous file operation. We need to figure out how to make it asynchronous.
+  // FIXME: This involves synchronous file operation. We need to figure out how
+  // to make it asynchronous.
   long long size;
   double modificationTimeMS;
   captureSnapshot(size, modificationTimeMS);
   clampSliceOffsets(size, start, end);
 
   long long length = end - start;
   std::unique_ptr<BlobData> blobData = BlobData::create();
   blobData->setContentType(contentType);
   if (!m_fileSystemURL.isEmpty()) {
     blobData->appendFileSystemURL(m_fileSystemURL, start, length,
                                   modificationTimeMS / msPerSecond);
   } else {
     ASSERT(!m_path.isEmpty());
     blobData->appendFile(m_path, start, length,
                          modificationTimeMS / msPerSecond);
   }
   return Blob::create(BlobDataHandle::create(std::move(blobData), length));
 }
 
 void File::captureSnapshot(long long& snapshotSize,
                            double& snapshotModificationTimeMS) const {
   if (hasValidSnapshotMetadata()) {
     snapshotSize = m_snapshotSize;
     snapshotModificationTimeMS = m_snapshotModificationTimeMS;
     return;
   }
 
-  // Obtains a snapshot of the file by capturing its current size and modification time. This is used when we slice a file for the first time.
-  // If we fail to retrieve the size or modification time, probably due to that the file has been deleted, 0 size is returned.
+  // Obtains a snapshot of the file by capturing its current size and
+  // modification time. This is used when we slice a file for the first time.
+  // If we fail to retrieve the size or modification time, probably due to that
+  // the file has been deleted, 0 size is returned.
   FileMetadata metadata;
   if (!hasBackingFile() || !getFileMetadata(m_path, metadata)) {
     snapshotSize = 0;
     snapshotModificationTimeMS = invalidFileTime();
     return;
   }
 
   snapshotSize = metadata.length;
   snapshotModificationTimeMS = metadata.modificationTime;
 }
@@ skipping 16 matching lines @@
   m_relativePath = String();
   Blob::close(executionContext, exceptionState);
 }
 
 void File::appendTo(BlobData& blobData) const {
   if (!m_hasBackingFile) {
     Blob::appendTo(blobData);
     return;
   }
 
-  // FIXME: This involves synchronous file operation. We need to figure out how to make it asynchronous.
+  // FIXME: This involves synchronous file operation. We need to figure out how
+  // to make it asynchronous.
   long long size;
   double modificationTimeMS;
   captureSnapshot(size, modificationTimeMS);
   if (!m_fileSystemURL.isEmpty()) {
     blobData.appendFileSystemURL(m_fileSystemURL, 0, size,
                                  modificationTimeMS / msPerSecond);
     return;
   }
   ASSERT(!m_path.isEmpty());
   blobData.appendFile(m_path, 0, size, modificationTimeMS / msPerSecond);
 }
 
 bool File::hasSameSource(const File& other) const {
   if (m_hasBackingFile != other.m_hasBackingFile)
     return false;
 
   if (m_hasBackingFile)
     return m_path == other.m_path;
 
   if (m_fileSystemURL.isEmpty() != other.m_fileSystemURL.isEmpty())
     return false;
 
   if (!m_fileSystemURL.isEmpty())
     return m_fileSystemURL == other.m_fileSystemURL;
 
   return uuid() == other.uuid();
 }
 
 }  // namespace blink