Bug 1376496 - Part 4 - FileDescriptorFile.cpp coding style fixes. r=jimm
authorHaik Aftandilian <haftandilian@mozilla.com>
Mon, 17 Jul 2017 23:48:42 -0700
changeset 371203 53d735d834049453a5883e6d3ccbbd60ef06b218
parent 371202 20114f663be1e5cb2ec93bc72f841d5610b3be15
child 371204 a3a129c768b6676a1f8f134828626792474f9d92
push id93049
push usercbook@mozilla.com
push dateThu, 27 Jul 2017 09:30:07 +0000
treeherdermozilla-inbound@5e9f7561c2eb [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjimm
bugs1376496
milestone56.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1376496 - Part 4 - FileDescriptorFile.cpp coding style fixes. r=jimm MozReview-Commit-ID: LN5o3WIW8ug
xpcom/io/FileDescriptorFile.cpp
--- a/xpcom/io/FileDescriptorFile.cpp
+++ b/xpcom/io/FileDescriptorFile.cpp
@@ -41,26 +41,26 @@ FileDescriptorFile::FileDescriptorFile(c
   aOther.mFile->Clone(getter_AddRefs(mFile));
 }
 
 //-----------------------------------------------------------------------------
 // FileDescriptorFile::nsIFile functions that we override logic for
 //-----------------------------------------------------------------------------
 
 NS_IMETHODIMP
-FileDescriptorFile::Clone(nsIFile **aFileOut)
+FileDescriptorFile::Clone(nsIFile** aFileOut)
 {
   RefPtr<FileDescriptorFile> fdFile = new FileDescriptorFile(*this);
   fdFile.forget(aFileOut);
   return NS_OK;
 }
 
 NS_IMETHODIMP
 FileDescriptorFile::OpenNSPRFileDesc(int32_t aFlags, int32_t aMode,
-                                     PRFileDesc **aRetval)
+                                     PRFileDesc** aRetval)
 {
   // Remove optional OS_READAHEAD flag so we test against PR_RDONLY
   aFlags &= ~nsIFile::OS_READAHEAD;
 
   // Remove optional/deprecated DELETE_ON_CLOSE flag
   aFlags &= ~nsIFile::DELETE_ON_CLOSE;
 
   // All other flags require write access to the file and
@@ -86,391 +86,395 @@ FileDescriptorFile::OpenNSPRFileDesc(int
   return NS_OK;
 }
 
 //-----------------------------------------------------------------------------
 // FileDescriptorFile::nsIFile functions that we delegate to underlying nsIFile
 //-----------------------------------------------------------------------------
 
 nsresult
-FileDescriptorFile::GetLeafName(nsAString &aLeafName)
+FileDescriptorFile::GetLeafName(nsAString& aLeafName)
 {
   return mFile->GetLeafName(aLeafName);
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetNativeLeafName(nsACString &aLeafName)
+FileDescriptorFile::GetNativeLeafName(nsACString& aLeafName)
 {
   return mFile->GetNativeLeafName(aLeafName);
 }
 
 nsresult
-FileDescriptorFile::GetTarget(nsAString &_retval)
+FileDescriptorFile::GetTarget(nsAString& aRetVal)
 {
-  return mFile->GetTarget(_retval);
+  return mFile->GetTarget(aRetVal);
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetNativeTarget(nsACString &_retval)
+FileDescriptorFile::GetNativeTarget(nsACString& aRetVal)
 {
-  return mFile->GetNativeTarget(_retval);
+  return mFile->GetNativeTarget(aRetVal);
 }
 
 nsresult
-FileDescriptorFile::GetPath(nsAString &_retval)
+FileDescriptorFile::GetPath(nsAString& aRetVal)
 {
-  return mFile->GetPath(_retval);
+  return mFile->GetPath(aRetVal);
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetNativePath(nsACString &_retval)
+FileDescriptorFile::GetNativePath(nsACString& aRetVal)
 {
-  return mFile->GetNativePath(_retval);
+  return mFile->GetNativePath(aRetVal);
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::Equals(nsIFile *inFile, bool *_retval)
+FileDescriptorFile::Equals(nsIFile* aOther, bool* aRetVal)
 {
-  return mFile->Equals(inFile, _retval);
+  return mFile->Equals(aOther, aRetVal);
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::Contains(nsIFile *inFile, bool *_retval)
+FileDescriptorFile::Contains(nsIFile* aOther, bool* aRetVal)
 {
-  return mFile->Contains(inFile, _retval);
+  return mFile->Contains(aOther, aRetVal);
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetParent(nsIFile **aParent)
+FileDescriptorFile::GetParent(nsIFile** aParent)
 {
   return mFile->GetParent(aParent);
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetFollowLinks(bool *aFollowLinks)
+FileDescriptorFile::GetFollowLinks(bool* aFollowLinks)
 {
   return mFile->GetFollowLinks(aFollowLinks);
 }
 
 //-----------------------------------------------------------------------------
 // FileDescriptorFile::nsIFile functions that are not currently supported
 //-----------------------------------------------------------------------------
 
 nsresult
-FileDescriptorFile::Append(const nsAString &node)
+FileDescriptorFile::Append(const nsAString& aNode)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::AppendNative(const nsACString &fragment)
+FileDescriptorFile::AppendNative(const nsACString& aFragment)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 FileDescriptorFile::Normalize()
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::Create(uint32_t type, uint32_t permissions)
+FileDescriptorFile::Create(uint32_t aType, uint32_t aPermissions)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 nsresult
-FileDescriptorFile::SetLeafName(const nsAString &aLeafName)
+FileDescriptorFile::SetLeafName(const nsAString& aLeafName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::SetNativeLeafName(const nsACString &aLeafName)
+FileDescriptorFile::SetNativeLeafName(const nsACString& aLeafName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 nsresult
-FileDescriptorFile::InitWithPath(const nsAString &filePath)
+FileDescriptorFile::InitWithPath(const nsAString& aPath)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::InitWithNativePath(const nsACString &filePath)
+FileDescriptorFile::InitWithNativePath(const nsACString& aPath)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::InitWithFile(nsIFile *aFile)
+FileDescriptorFile::InitWithFile(nsIFile* aFile)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 FileDescriptorFile::SetFollowLinks(bool aFollowLinks)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 nsresult
-FileDescriptorFile::AppendRelativePath(const nsAString &node)
+FileDescriptorFile::AppendRelativePath(const nsAString& aNode)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::AppendRelativeNativePath(const nsACString &fragment)
+FileDescriptorFile::AppendRelativeNativePath(const nsACString& aFragment)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetPersistentDescriptor(nsACString &aPersistentDescriptor)
+FileDescriptorFile::GetPersistentDescriptor(nsACString& aPersistentDescriptor)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::SetPersistentDescriptor(const nsACString &aPersistentDescriptor)
+FileDescriptorFile::SetPersistentDescriptor(const nsACString& aPersistentDescriptor)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetRelativeDescriptor(nsIFile *fromFile, nsACString& _retval)
+FileDescriptorFile::GetRelativeDescriptor(nsIFile* aFromFile,
+                                          nsACString& aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::SetRelativeDescriptor(nsIFile *fromFile,
-                                   const nsACString& relativeDesc)
+FileDescriptorFile::SetRelativeDescriptor(nsIFile* aFromFile,
+                                          const nsACString& aRelativeDesc)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetRelativePath(nsIFile *fromFile, nsACString& _retval)
+FileDescriptorFile::GetRelativePath(nsIFile* aFromFile, nsACString& aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::SetRelativePath(nsIFile *fromFile,
-                                     const nsACString& relativePath)
+FileDescriptorFile::SetRelativePath(nsIFile* aFromFile,
+                                    const nsACString& aRelativePath)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 nsresult
-FileDescriptorFile::CopyTo(nsIFile *newParentDir, const nsAString &newName)
+FileDescriptorFile::CopyTo(nsIFile* aNewParentDir, const nsAString& aNewName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::CopyToNative(nsIFile *newParent, const nsACString &newName)
+FileDescriptorFile::CopyToNative(nsIFile* aNewParent,
+                                 const nsACString& aNewName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 nsresult
-FileDescriptorFile::CopyToFollowingLinks(nsIFile *newParentDir,
-                                  const nsAString &newName)
+FileDescriptorFile::CopyToFollowingLinks(nsIFile* aNewParentDir,
+                                         const nsAString& aNewName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::CopyToFollowingLinksNative(nsIFile *newParent,
-                                        const nsACString &newName)
+FileDescriptorFile::CopyToFollowingLinksNative(nsIFile* aNewParent,
+                                               const nsACString& aNewName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 nsresult
-FileDescriptorFile::MoveTo(nsIFile *newParentDir, const nsAString &newName)
+FileDescriptorFile::MoveTo(nsIFile* aNewParentDir, const nsAString& aNewName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::MoveToNative(nsIFile *newParent, const nsACString &newName)
+FileDescriptorFile::MoveToNative(nsIFile* aNewParent,
+                                 const nsACString& aNewName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::RenameTo(nsIFile *newParentDir, const nsAString &newName)
+FileDescriptorFile::RenameTo(nsIFile* aNewParentDir, const nsAString& aNewName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::RenameToNative(nsIFile *newParentDir, const nsACString &newName)
+FileDescriptorFile::RenameToNative(nsIFile* aNewParentDir,
+                                   const nsACString& aNewName)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::Remove(bool recursive)
+FileDescriptorFile::Remove(bool aRecursive)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetPermissions(uint32_t *aPermissions)
+FileDescriptorFile::GetPermissions(uint32_t* aPermissions)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 FileDescriptorFile::SetPermissions(uint32_t aPermissions)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetPermissionsOfLink(uint32_t *aPermissionsOfLink)
+FileDescriptorFile::GetPermissionsOfLink(uint32_t* aPermissionsOfLink)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 FileDescriptorFile::SetPermissionsOfLink(uint32_t aPermissions)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetLastModifiedTime(PRTime *aLastModTime)
+FileDescriptorFile::GetLastModifiedTime(PRTime* aLastModTime)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 FileDescriptorFile::SetLastModifiedTime(PRTime aLastModTime)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetLastModifiedTimeOfLink(PRTime *aLastModTimeOfLink)
+FileDescriptorFile::GetLastModifiedTimeOfLink(PRTime* aLastModTimeOfLink)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 FileDescriptorFile::SetLastModifiedTimeOfLink(PRTime aLastModTimeOfLink)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetFileSize(int64_t *aFileSize)
+FileDescriptorFile::GetFileSize(int64_t* aFileSize)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 FileDescriptorFile::SetFileSize(int64_t aFileSize)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetFileSizeOfLink(int64_t *aFileSize)
+FileDescriptorFile::GetFileSizeOfLink(int64_t* aFileSize)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::Exists(bool *_retval)
+FileDescriptorFile::Exists(bool* aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::IsWritable(bool *_retval)
+FileDescriptorFile::IsWritable(bool* aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::IsReadable(bool *_retval)
+FileDescriptorFile::IsReadable(bool* aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::IsExecutable(bool *_retval)
+FileDescriptorFile::IsExecutable(bool* aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::IsHidden(bool *_retval)
+FileDescriptorFile::IsHidden(bool* aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::IsDirectory(bool *_retval)
+FileDescriptorFile::IsDirectory(bool* aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::IsFile(bool *_retval)
+FileDescriptorFile::IsFile(bool* aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::IsSymlink(bool *_retval)
+FileDescriptorFile::IsSymlink(bool* aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::IsSpecial(bool *_retval)
+FileDescriptorFile::IsSpecial(bool* aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::CreateUnique(uint32_t type, uint32_t attributes)
+FileDescriptorFile::CreateUnique(uint32_t aType, uint32_t aAttributes)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetDirectoryEntries(nsISimpleEnumerator **entries)
+FileDescriptorFile::GetDirectoryEntries(nsISimpleEnumerator** aEntries)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::OpenANSIFileDesc(const char *mode, FILE **_retval)
+FileDescriptorFile::OpenANSIFileDesc(const char* aMode, FILE** aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::Load(PRLibrary **_retval)
+FileDescriptorFile::Load(PRLibrary** aRetVal)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
-FileDescriptorFile::GetDiskSpaceAvailable(int64_t *aDiskSpaceAvailable)
+FileDescriptorFile::GetDiskSpaceAvailable(int64_t* aDiskSpaceAvailable)
 {
   return NS_ERROR_NOT_IMPLEMENTED;
 }
 
 NS_IMETHODIMP
 FileDescriptorFile::Reveal()
 {
   return NS_ERROR_NOT_IMPLEMENTED;