Clean up log messages in vt_video_decode_accelerator_mac.cc.

content/common/gpu/media/vt_video_decode_accelerator_mac.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <algorithm>
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 #include <stddef.h>
@@ skipping 106 matching lines @@
   base::ScopedCFTypeRef<CMFormatDescriptionRef> format;
   OSStatus status = CMVideoFormatDescriptionCreateFromH264ParameterSets(
       kCFAllocatorDefault,
       2,                    // parameter_set_count
       data_ptrs,            // &parameter_set_pointers
       data_sizes,           // &parameter_set_sizes
       kNALUHeaderLength,    // nal_unit_header_length
       format.InitializeInto());
   if (status) {
     OSSTATUS_DLOG(WARNING, status)
-        << "Failed to create CMVideoFormatDescription.";
+        << "Failed to create CMVideoFormatDescription";
     return false;
   }
 
   base::ScopedCFTypeRef<CFMutableDictionaryRef> decoder_config(
       CFDictionaryCreateMutable(
           kCFAllocatorDefault,
           1,  // capacity
           &kCFTypeDictionaryKeyCallBacks,
           &kCFTypeDictionaryValueCallBacks));
   if (!decoder_config.get())
@@ skipping 16 matching lines @@
 
   base::ScopedCFTypeRef<VTDecompressionSessionRef> session;
   status = VTDecompressionSessionCreate(
       kCFAllocatorDefault,
       format,               // video_format_description
       decoder_config,       // video_decoder_specification
       image_config,         // destination_image_buffer_attributes
       &callback,            // output_callback
       session.InitializeInto());
   if (status) {
-    OSSTATUS_DLOG(WARNING, status) << "Failed to create VTDecompressionSession";
+    OSSTATUS_DLOG(WARNING, status)
+        << "Failed to create VTDecompressionSession";
     return false;
   }
 
   return true;
 }
 
 // The purpose of this function is to preload the generic and hardware-specific
 // libraries required by VideoToolbox before the GPU sandbox is enabled.
 // VideoToolbox normally loads the hardware-specific libraries lazily, so we
 // must actually create a decompression session. If creating a decompression
 // session fails, hardware decoding will be disabled (Initialize() will always
 // return false).
 static bool InitializeVideoToolboxInternal() {
   if (!IsVtInitialized()) {
     // CoreVideo is also required, but the loader stops after the first path is
     // loaded. Instead we rely on the transitive dependency from VideoToolbox to
     // CoreVideo.
     StubPathMap paths;
     paths[kModuleVt].push_back(FILE_PATH_LITERAL(
         "/System/Library/Frameworks/VideoToolbox.framework/VideoToolbox"));
     if (!InitializeStubs(paths)) {
-      LOG(WARNING) << "Failed to initialize VideoToolbox framework. "
-                   << "Hardware accelerated video decoding will be disabled.";
+      DLOG(WARNING) << "Failed to initialize VideoToolbox framework";
       return false;
     }
   }
 
   // Create a hardware decoding session.
   // SPS and PPS data are taken from a 480p sample (buck2.mp4).
   const uint8_t sps_normal[] = {0x67, 0x64, 0x00, 0x1e, 0xac, 0xd9, 0x80, 0xd4,
                                 0x3d, 0xa1, 0x00, 0x00, 0x03, 0x00, 0x01, 0x00,
                                 0x00, 0x03, 0x00, 0x30, 0x8f, 0x16, 0x2d, 0x9a};
   const uint8_t pps_normal[] = {0x68, 0xe9, 0x7b, 0xcb};
   if (!CreateVideoToolboxSession(sps_normal, arraysize(sps_normal), pps_normal,
                                  arraysize(pps_normal), true)) {
-    LOG(WARNING) << "Failed to create hardware VideoToolbox session. "
-                 << "Hardware accelerated video decoding will be disabled.";
+    DLOG(WARNING) << "Failed to create hardware VideoToolbox session";
     return false;
   }
 
   // Create a software decoding session.
   // SPS and PPS data are taken from a 18p sample (small2.mp4).
   const uint8_t sps_small[] = {0x67, 0x64, 0x00, 0x0a, 0xac, 0xd9, 0x89, 0x7e,
                                0x22, 0x10, 0x00, 0x00, 0x3e, 0x90, 0x00, 0x0e,
                                0xa6, 0x08, 0xf1, 0x22, 0x59, 0xa0};
   const uint8_t pps_small[] = {0x68, 0xe9, 0x79, 0x72, 0xc0};
   if (!CreateVideoToolboxSession(sps_small, arraysize(sps_small), pps_small,
                                  arraysize(pps_small), false)) {
-    LOG(WARNING) << "Failed to create software VideoToolbox session. "
-                 << "Hardware accelerated video decoding will be disabled.";
+    DLOG(WARNING) << "Failed to create software VideoToolbox session";
     return false;
   }
 
   return true;
 }
 
 bool InitializeVideoToolbox() {
   // InitializeVideoToolbox() is called only from the GPU process main thread;
   // once for sandbox warmup, and then once each time a VTVideoDecodeAccelerator
   // is initialized.
@@ skipping 181 matching lines @@
   coded_size_.SetSize(coded_dimensions.width, coded_dimensions.height);
 
   // Prepare VideoToolbox configuration dictionaries.
   base::ScopedCFTypeRef<CFMutableDictionaryRef> decoder_config(
       CFDictionaryCreateMutable(
           kCFAllocatorDefault,
           1,  // capacity
           &kCFTypeDictionaryKeyCallBacks,
           &kCFTypeDictionaryValueCallBacks));
   if (!decoder_config.get()) {
-    DLOG(ERROR) << "Failed to create CFMutableDictionary.";
+    DLOG(ERROR) << "Failed to create CFMutableDictionary";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
     return false;
   }
 
   CFDictionarySetValue(
       decoder_config,
       // kVTVideoDecoderSpecification_EnableHardwareAcceleratedVideoDecoder
       CFSTR("EnableHardwareAcceleratedVideoDecoder"),
       kCFBooleanTrue);
 
   base::ScopedCFTypeRef<CFMutableDictionaryRef> image_config(
       BuildImageConfig(coded_dimensions));
   if (!image_config.get()) {
-    DLOG(ERROR) << "Failed to create decoder image configuration.";
+    DLOG(ERROR) << "Failed to create decoder image configuration";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
     return false;
   }
 
   // Ensure that the old decoder emits all frames before the new decoder can
   // emit any.
   if (!FinishDelayedFrames())
     return false;
 
   session_.reset();
@@ skipping 504 matching lines @@
         last_pps_.clear();
         poc_.Reset();
         pending_flush_tasks_.pop();
         client_->NotifyResetDone();
         task_queue_.pop();
         return true;
       }
       return false;
 
     case TASK_DESTROY:
-      NOTREACHED() << "Can't destroy while in STATE_DECODING.";
+      NOTREACHED() << "Can't destroy while in STATE_DECODING";
       NotifyError(ILLEGAL_STATE, SFT_PLATFORM_ERROR);
       return false;
   }
 }
 
 bool VTVideoDecodeAccelerator::ProcessReorderQueue() {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, STATE_DECODING);
 
   if (reorder_queue_.empty())
@@ skipping 177 matching lines @@
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(16, 16);
     profile.max_resolution.SetSize(4096, 2160);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 }  // namespace content