ppapi/cpp/logging.h -> base/logging.h

BUG=889703

Change-Id: I4482aa852393f4bdc67eaf8b5732f0b58e1974cf
Reviewed-on: https://chromium-review.googlesource.com/c/1317211Reviewed-by: Luciano Pacheco <lucmult@chromium.org>
Commit-Queue: Anand Mistry <amistry@chromium.org>
Cr-Commit-Position: refs/heads/master@{#605258}

chrome/browser/resources/chromeos/zip_archiver/cpp/compressor.cc

@@ -10,6 +10,7 @@
 #include <string>
 #include <utility>
 
+#include "base/logging.h"
 #include "base/time/time.h"
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/compressor_archive_minizip.h"
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/compressor_io_javascript_stream.h"
@@ -82,18 +83,18 @@ void Compressor::AddToArchive(const pp::VarDictionary& dictionary) {
 
 void Compressor::AddToArchiveCallback(int32_t,
                                       const pp::VarDictionary& dictionary) {
-  PP_DCHECK(dictionary.Get(request::key::kPathname).is_string());
+  DCHECK(dictionary.Get(request::key::kPathname).is_string());
   std::string pathname = dictionary.Get(request::key::kPathname).AsString();
 
-  PP_DCHECK(dictionary.Get(request::key::kFileSize).is_string());
+  DCHECK(dictionary.Get(request::key::kFileSize).is_string());
   int64_t file_size =
       request::GetInt64FromString(dictionary, request::key::kFileSize);
-  PP_DCHECK(file_size >= 0);
+  DCHECK_GE(file_size, 0);
 
-  PP_DCHECK(dictionary.Get(request::key::kIsDirectory).is_bool());
+  DCHECK(dictionary.Get(request::key::kIsDirectory).is_bool());
   bool is_directory = dictionary.Get(request::key::kIsDirectory).AsBool();
 
-  PP_DCHECK(dictionary.Get(request::key::kModificationTime).is_string());
+  DCHECK(dictionary.Get(request::key::kModificationTime).is_string());
   // modification_time comes from a JS Date object, which expresses time in
   // milliseconds since the UNIX epoch.
   base::Time modification_time = base::Time::FromJsTime(
@@ -113,18 +114,18 @@ void Compressor::AddToArchiveCallback(int32_t,
 }
 
 void Compressor::ReadFileChunkDone(const pp::VarDictionary& dictionary) {
-  PP_DCHECK(dictionary.Get(request::key::kLength).is_string());
+  DCHECK(dictionary.Get(request::key::kLength).is_string());
   int64_t read_bytes =
       request::GetInt64FromString(dictionary, request::key::kLength);
 
-  PP_DCHECK(dictionary.Get(request::key::kChunkBuffer).is_array_buffer());
+  DCHECK(dictionary.Get(request::key::kChunkBuffer).is_array_buffer());
   pp::VarArrayBuffer array_buffer(dictionary.Get(request::key::kChunkBuffer));
 
   compressor_stream_->ReadFileChunkDone(read_bytes, &array_buffer);
 }
 
 void Compressor::WriteChunkDone(const pp::VarDictionary& dictionary) {
-  PP_DCHECK(dictionary.Get(request::key::kLength).is_string());
+  DCHECK(dictionary.Get(request::key::kLength).is_string());
   int64_t written_bytes =
       request::GetInt64FromString(dictionary, request::key::kLength);
 
@@ -132,7 +133,7 @@ void Compressor::WriteChunkDone(const pp::VarDictionary& dictionary) {
 }
 
 void Compressor::CloseArchive(const pp::VarDictionary& dictionary) {
-  PP_DCHECK(dictionary.Get(request::key::kHasError).is_bool());
+  DCHECK(dictionary.Get(request::key::kHasError).is_bool());
   bool has_error = dictionary.Get(request::key::kHasError).AsBool();
 
   // If an error has occurred, no more write chunk requests are sent and

chrome/browser/resources/chromeos/zip_archiver/cpp/compressor_archive_minizip.cc

@@ -9,10 +9,10 @@
 #include <cstring>
 #include <utility>
 
+#include "base/logging.h"
 #include "base/time/time.h"
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/compressor_io_javascript_stream.h"
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/compressor_stream.h"
-#include "ppapi/cpp/logging.h"
 
 namespace {
 
@@ -206,7 +206,7 @@ bool CompressorArchiveMinizip::AddToArchive(const std::string& filename,
     int64_t remaining_size = file_size;
     while (remaining_size > 0) {
       int64_t chunk_size = std::min(remaining_size, kMaximumDataChunkSize);
-      PP_DCHECK(chunk_size > 0);
+      DCHECK_GT(chunk_size, 0);
 
       int64_t read_bytes =
           compressor_stream_->Read(chunk_size, destination_buffer_.get());

chrome/browser/resources/chromeos/zip_archiver/cpp/compressor_io_javascript_stream.cc

@@ -10,7 +10,6 @@
 #include <utility>
 
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/javascript_compressor_requestor_interface.h"
-#include "ppapi/cpp/logging.h"
 
 namespace {
 

chrome/browser/resources/chromeos/zip_archiver/cpp/module.cc

@@ -7,13 +7,13 @@
 #include <sstream>
 #include <utility>
 
+#include "base/logging.h"
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/compressor.h"
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/javascript_message_sender_interface.h"
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/request.h"
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/volume.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/instance_handle.h"
-#include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/var_dictionary.h"
 #include "ppapi/utility/threading/lock.h"
@@ -53,8 +53,8 @@ class JavaScriptMessageSender : public JavaScriptMessageSenderInterface {
                                     const std::string& request_id,
                                     int64_t offset,
                                     int64_t bytes_to_read) {
-    PP_DCHECK(offset >= 0);
-    PP_DCHECK(bytes_to_read > 0);
+    DCHECK_GE(offset, 0);
+    DCHECK_GT(bytes_to_read, 0);
     JavaScriptPostMessage(request::CreateReadChunkRequest(
         file_system_id, request_id, offset, bytes_to_read));
   }
@@ -161,10 +161,10 @@ class NaclArchiveInstance : public pp::Instance {
 
   // Handler for messages coming in from JS via postMessage().
   virtual void HandleMessage(const pp::Var& var_message) {
-    PP_DCHECK(var_message.is_dictionary());
+    DCHECK(var_message.is_dictionary());
     pp::VarDictionary var_dict(var_message);
 
-    PP_DCHECK(var_dict.Get(request::key::kOperation).is_int());
+    DCHECK(var_dict.Get(request::key::kOperation).is_int());
     int operation = var_dict.Get(request::key::kOperation).AsInt();
 
     if (request::IsPackRequest(operation))
@@ -177,11 +177,11 @@ class NaclArchiveInstance : public pp::Instance {
   // Processes unpack messages.
   void HandleUnpackMessage(const pp::VarDictionary& var_dict,
                            const int operation) {
-    PP_DCHECK(var_dict.Get(request::key::kFileSystemId).is_string());
+    DCHECK(var_dict.Get(request::key::kFileSystemId).is_string());
     std::string file_system_id =
         var_dict.Get(request::key::kFileSystemId).AsString();
 
-    PP_DCHECK(var_dict.Get(request::key::kRequestId).is_string());
+    DCHECK(var_dict.Get(request::key::kRequestId).is_string());
     std::string request_id = var_dict.Get(request::key::kRequestId).AsString();
 
     // Processes operation.
@@ -220,20 +220,20 @@ class NaclArchiveInstance : public pp::Instance {
         break;
 
       case request::CLOSE_VOLUME: {
-        PP_DCHECK(volumes_.find(file_system_id) != volumes_.end());
+        DCHECK(volumes_.find(file_system_id) != volumes_.end());
         volumes_.erase(file_system_id);
         break;
       }
 
       default:
-        PP_NOTREACHED();
+        NOTREACHED();
     }
   }
 
   // Processes pack messages.
   void HandlePackMessage(const pp::VarDictionary& var_dict,
                          const int operation) {
-    PP_DCHECK(var_dict.Get(request::key::kCompressorId).is_int());
+    DCHECK(var_dict.Get(request::key::kCompressorId).is_int());
     int compressor_id = var_dict.Get(request::key::kCompressorId).AsInt();
 
     switch (operation) {
@@ -273,7 +273,7 @@ class NaclArchiveInstance : public pp::Instance {
       }
 
       default:
-        PP_NOTREACHED();
+        NOTREACHED();
     }
   }
 
@@ -289,7 +289,7 @@ class NaclArchiveInstance : public pp::Instance {
                     const std::string& file_system_id,
                     const std::string& request_id) {
     // Should not call ReadMetadata for a Volume already present in NaCl.
-    PP_DCHECK(volumes_.find(file_system_id) == volumes_.end());
+    DCHECK(volumes_.find(file_system_id) == volumes_.end());
 
     std::unique_ptr<Volume> volume = std::make_unique<Volume>(
         instance_handle_, file_system_id, &message_sender_);
@@ -302,8 +302,8 @@ class NaclArchiveInstance : public pp::Instance {
     Volume* raw_volume = volume.get();
     volumes_[file_system_id] = std::move(volume);
 
-    PP_DCHECK(var_dict.Get(request::key::kEncoding).is_string());
-    PP_DCHECK(var_dict.Get(request::key::kArchiveSize).is_string());
+    DCHECK(var_dict.Get(request::key::kEncoding).is_string());
+    DCHECK(var_dict.Get(request::key::kArchiveSize).is_string());
 
     raw_volume->ReadMetadata(
         request_id, var_dict.Get(request::key::kEncoding).AsString(),
@@ -313,10 +313,10 @@ class NaclArchiveInstance : public pp::Instance {
   void ReadChunkDone(const pp::VarDictionary& var_dict,
                      const std::string& file_system_id,
                      const std::string& request_id) {
-    PP_DCHECK(var_dict.Get(request::key::kChunkBuffer).is_array_buffer());
+    DCHECK(var_dict.Get(request::key::kChunkBuffer).is_array_buffer());
     pp::VarArrayBuffer array_buffer(var_dict.Get(request::key::kChunkBuffer));
 
-    PP_DCHECK(var_dict.Get(request::key::kOffset).is_string());
+    DCHECK(var_dict.Get(request::key::kOffset).is_string());
     int64_t read_offset =
         request::GetInt64FromString(var_dict, request::key::kOffset);
 
@@ -341,7 +341,7 @@ class NaclArchiveInstance : public pp::Instance {
   void ReadPassphraseDone(const pp::VarDictionary& var_dict,
                           const std::string& file_system_id,
                           const std::string& request_id) {
-    PP_DCHECK(var_dict.Get(request::key::kPassphrase).is_string());
+    DCHECK(var_dict.Get(request::key::kPassphrase).is_string());
     std::string passphrase(var_dict.Get(request::key::kPassphrase).AsString());
 
     volume_iterator iterator = volumes_.find(file_system_id);
@@ -363,32 +363,32 @@ class NaclArchiveInstance : public pp::Instance {
   void OpenFile(const pp::VarDictionary& var_dict,
                 const std::string& file_system_id,
                 const std::string& request_id) {
-    PP_DCHECK(var_dict.Get(request::key::kIndex).is_string());
+    DCHECK(var_dict.Get(request::key::kIndex).is_string());
     int64_t index = request::GetInt64FromString(var_dict, request::key::kIndex);
 
-    PP_DCHECK(var_dict.Get(request::key::kEncoding).is_string());
+    DCHECK(var_dict.Get(request::key::kEncoding).is_string());
     std::string encoding(var_dict.Get(request::key::kEncoding).AsString());
 
-    PP_DCHECK(var_dict.Get(request::key::kArchiveSize).is_string());
+    DCHECK(var_dict.Get(request::key::kArchiveSize).is_string());
     int64_t archive_size =
         request::GetInt64FromString(var_dict, request::key::kArchiveSize);
 
     volume_iterator iterator = volumes_.find(file_system_id);
-    PP_DCHECK(iterator != volumes_.end());  // Should call OpenFile after
-                                            // ReadMetadata.
+    // Should call OpenFile after ReadMetadata.
+    DCHECK(iterator != volumes_.end());
     iterator->second->OpenFile(request_id, index, encoding, archive_size);
   }
 
   void CloseFile(const pp::VarDictionary& var_dict,
                  const std::string& file_system_id,
                  const std::string& request_id) {
-    PP_DCHECK(var_dict.Get(request::key::kOpenRequestId).is_string());
+    DCHECK(var_dict.Get(request::key::kOpenRequestId).is_string());
     std::string open_request_id(
         var_dict.Get(request::key::kOpenRequestId).AsString());
 
     volume_iterator iterator = volumes_.find(file_system_id);
-    PP_DCHECK(iterator !=
-              volumes_.end());  // Should call CloseFile after OpenFile.
+    DCHECK(iterator !=
+           volumes_.end());  // Should call CloseFile after OpenFile.
 
     iterator->second->CloseFile(request_id, open_request_id);
   }
@@ -396,13 +396,12 @@ class NaclArchiveInstance : public pp::Instance {
   void ReadFile(const pp::VarDictionary& var_dict,
                 const std::string& file_system_id,
                 const std::string& request_id) {
-    PP_DCHECK(var_dict.Get(request::key::kOpenRequestId).is_string());
-    PP_DCHECK(var_dict.Get(request::key::kOffset).is_string());
-    PP_DCHECK(var_dict.Get(request::key::kLength).is_string());
+    DCHECK(var_dict.Get(request::key::kOpenRequestId).is_string());
+    DCHECK(var_dict.Get(request::key::kOffset).is_string());
+    DCHECK(var_dict.Get(request::key::kLength).is_string());
 
     volume_iterator iterator = volumes_.find(file_system_id);
-    PP_DCHECK(iterator !=
-              volumes_.end());  // Should call ReadFile after OpenFile.
+    DCHECK(iterator != volumes_.end());  // Should call ReadFile after OpenFile.
 
     // Passing the entire dictionary because pp::CompletionCallbackFactory
     // cannot create callbacks with more than 3 parameters. Here we need 4:
@@ -429,7 +428,7 @@ class NaclArchiveInstance : public pp::Instance {
 
   void AddToArchive(const pp::VarDictionary& var_dict, int compressor_id) {
     compressor_iterator iterator = compressors_.find(compressor_id);
-    PP_DCHECK(iterator != compressors_.end());
+    DCHECK(iterator != compressors_.end());
 
     iterator->second->AddToArchive(var_dict);
   }
@@ -437,14 +436,14 @@ class NaclArchiveInstance : public pp::Instance {
   void ReadFileChunkDone(const pp::VarDictionary& var_dict,
                          const int compressor_id) {
     compressor_iterator iterator = compressors_.find(compressor_id);
-    PP_DCHECK(iterator != compressors_.end());
+    DCHECK(iterator != compressors_.end());
 
     iterator->second->ReadFileChunkDone(var_dict);
   }
 
   void WriteChunkDone(const pp::VarDictionary& var_dict, int compressor_id) {
     compressor_iterator iterator = compressors_.find(compressor_id);
-    PP_DCHECK(iterator != compressors_.end());
+    DCHECK(iterator != compressors_.end());
 
     iterator->second->WriteChunkDone(var_dict);
   }

chrome/browser/resources/chromeos/zip_archiver/cpp/volume.cc

@@ -8,6 +8,7 @@
 #include <sstream>
 #include <utility>
 
+#include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/char_coding.h"
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/javascript_message_sender_interface.h"
@@ -84,7 +85,7 @@ void ConstructMetadata(int64_t index,
     if (!old_entry_metadata_var.is_undefined()) {
       pp::VarDictionary old_entry_metadata =
           pp::VarDictionary(old_entry_metadata_var);
-      PP_DCHECK(old_entry_metadata.Get("isDirectory").AsBool());
+      DCHECK(old_entry_metadata.Get("isDirectory").AsBool());
       entry_metadata.Set("entries", old_entry_metadata.Get("entries"));
     }
   } else {  // Get next parent on the way to the entry.
@@ -132,8 +133,8 @@ class JavaScriptRequestor : public JavaScriptRequestorInterface {
   void RequestFileChunk(const std::string& request_id,
                         int64_t offset,
                         int64_t bytes_to_read) override {
-    PP_DCHECK(offset >= 0);
-    PP_DCHECK(bytes_to_read > 0);
+    DCHECK_GE(offset, 0);
+    DCHECK_GT(bytes_to_read, 0);
     volume_->message_sender()->SendFileChunkRequest(
         volume_->file_system_id(), request_id, offset, bytes_to_read);
   }
@@ -258,14 +259,14 @@ void Volume::ReadFile(const std::string& request_id,
 void Volume::ReadChunkDone(const std::string& request_id,
                            const pp::VarArrayBuffer& array_buffer,
                            int64_t read_offset) {
-  PP_DCHECK(volume_archive_);
+  DCHECK(volume_archive_);
 
   static_cast<VolumeReaderJavaScriptStream*>(volume_archive_->reader())
       ->SetBufferAndSignal(array_buffer, read_offset);
 }
 
 void Volume::ReadChunkError(const std::string& request_id) {
-  PP_DCHECK(volume_archive_);
+  DCHECK(volume_archive_);
 
   static_cast<VolumeReaderJavaScriptStream*>(volume_archive_->reader())
       ->ReadErrorSignal();
@@ -273,7 +274,7 @@ void Volume::ReadChunkError(const std::string& request_id) {
 
 void Volume::ReadPassphraseDone(const std::string& request_id,
                                 const std::string& passphrase) {
-  PP_DCHECK(volume_archive_);
+  DCHECK(volume_archive_);
 
   job_lock_.Acquire();
   if (request_id == reader_request_id_) {
@@ -284,7 +285,7 @@ void Volume::ReadPassphraseDone(const std::string& request_id,
 }
 
 void Volume::ReadPassphraseError(const std::string& request_id) {
-  PP_DCHECK(volume_archive_);
+  DCHECK(volume_archive_);
 
   job_lock_.Acquire();
   if (request_id == reader_request_id_) {
@@ -462,7 +463,7 @@ void Volume::ReadFileCallback(int32_t /*result*/,
       request::GetInt64FromString(dictionary, request::key::kOffset);
   int64_t length =
       request::GetInt64FromString(dictionary, request::key::kLength);
-  PP_DCHECK(length > 0);  // JavaScript must not make requests with length <= 0.
+  DCHECK_GT(length, 0);  // JavaScript must not make requests with length <= 0.
 
   job_lock_.Acquire();
   if (open_request_id != reader_request_id_) {

chrome/browser/resources/chromeos/zip_archiver/cpp/volume_reader_javascript_stream.cc

@@ -9,7 +9,6 @@
 
 #include "base/files/file.h"
 #include "chrome/browser/resources/chromeos/zip_archiver/cpp/javascript_requestor_interface.h"
-#include "ppapi/cpp/logging.h"
 #include "third_party/minizip/src/unzip.h"
 
 VolumeReaderJavaScriptStream::VolumeReaderJavaScriptStream(
@@ -54,7 +53,7 @@ int64_t VolumeReaderJavaScriptStream::archive_size() {
 void VolumeReaderJavaScriptStream::SetBufferAndSignal(
     const pp::VarArrayBuffer& array_buffer,
     int64_t read_offset) {
-  PP_DCHECK(read_offset >= 0);
+  DCHECK_GE(read_offset, 0);
 
   // Ignore read ahead in case offset was changed using Skip or Seek and in case
   // we already have available data. This can happen in case of 2+ RequestChunk
@@ -109,7 +108,7 @@ void VolumeReaderJavaScriptStream::PassphraseErrorSignal() {
 
 int64_t VolumeReaderJavaScriptStream::Read(int64_t bytes_to_read,
                                            const void** destination_buffer) {
-  PP_DCHECK(bytes_to_read > 0);
+  DCHECK_GT(bytes_to_read, 0);
 
   base::AutoLock al(shared_state_lock_);
 
@@ -194,7 +193,7 @@ int64_t VolumeReaderJavaScriptStream::Seek(int64_t offset,
       new_offset = archive_size_ + offset;
       break;
     default:
-      PP_NOTREACHED();
+      NOTREACHED();
       return -1;
   }