Modify Chromoting logging to hook into base logging.

remoting/client/plugin/pepper_view.cc

 // Copyright (c) 2011 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 "remoting/client/plugin/pepper_view.h"
 
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "ppapi/cpp/graphics_2d.h"
 #include "ppapi/cpp/image_data.h"
@@ skipping 30 matching lines @@
 
   task_factory_.RevokeAll();
 }
 
 void PepperView::Paint() {
   DCHECK(CurrentlyOnPluginThread());
 
   TraceContext::tracer()->PrintString("Start Paint.");
 
   if (is_static_fill_) {
-    instance_->Log(logging::LOG_INFO,
-                   "Static filling %08x", static_fill_color_);
+    LOG(INFO) << "Static filling " << static_fill_color_;
     pp::ImageData image(instance_, pp::ImageData::GetNativeImageDataFormat(),
                         pp::Size(graphics2d_.size().width(),
                                  graphics2d_.size().height()),
                         false);
     if (image.is_null()) {
-      instance_->Log(logging::LOG_ERROR,
-                     "Unable to allocate image of size: %dx%d",
-                     graphics2d_.size().width(), graphics2d_.size().height());
+      LOG(ERROR) << "Unable to allocate image of size: "
+                 << graphics2d_.size().width() << " x "
+                 << graphics2d_.size().height();
       return;
     }
 
     for (int y = 0; y < image.size().height(); y++) {
       for (int x = 0; x < image.size().width(); x++) {
         *image.GetAddr32(pp::Point(x, y)) = static_fill_color_;
       }
     }
 
     // For ReplaceContents, make sure the image size matches the device context
@@ skipping 22 matching lines @@
 }
 
 void PepperView::PaintFrame(media::VideoFrame* frame, UpdatedRects* rects) {
   DCHECK(CurrentlyOnPluginThread());
 
   TraceContext::tracer()->PrintString("Start Paint Frame.");
 
   SetHostSize(gfx::Size(frame->width(), frame->height()));
 
   if (!backing_store_.get() || backing_store_->is_null()) {
-    instance_->Log(logging::LOG_ERROR, "Backing store is not available.");
+    LOG(ERROR) << "Backing store is not available.";
     return;
   }
 
   base::Time start_time = base::Time::Now();
 
   // Copy updated regions to the backing store and then paint the regions.
   bool changes_made = false;
   for (size_t i = 0; i < rects->size(); ++i)
     changes_made |= PaintRect(frame, (*rects)[i]);
 
@@ skipping 120 matching lines @@
 
 bool PepperView::SetPluginSize(const gfx::Size& plugin_size) {
   if (plugin_size_ == plugin_size)
     return false;
   plugin_size_ = plugin_size;
 
   pp::Size pp_size = pp::Size(plugin_size.width(), plugin_size.height());
 
   graphics2d_ = pp::Graphics2D(instance_, pp_size, true);
   if (!instance_->BindGraphics(graphics2d_)) {
-    instance_->Log(logging::LOG_ERROR, "Couldn't bind the device context.");
+    LOG(ERROR) << "Couldn't bind the device context.";
     return false;
   }
 
   if (plugin_size.IsEmpty())
     return false;
 
   // Allocate the backing store to save the desktop image.
   if ((backing_store_.get() == NULL) ||
       (backing_store_->size() != pp_size)) {
-    instance_->Log(logging::LOG_INFO, "Allocate backing store: %d x %d",
-                   plugin_size.width(), plugin_size.height());
+    LOG(INFO) << "Allocate backing store: "
+              << plugin_size.width() << " x " << plugin_size.height();
     backing_store_.reset(
         new pp::ImageData(instance_, pp::ImageData::GetNativeImageDataFormat(),
                           pp_size, false));
     DCHECK(backing_store_.get() && !backing_store_->is_null())
         << "Not enough memory for backing store.";
   }
   return true;
 }
 
 double PepperView::GetHorizontalScaleRatio() const {
@@ skipping 27 matching lines @@
                                               base::TimeDelta());
   (*frame_out)->AddRef();
   done->Run();
   delete done;
 }
 
 void PepperView::ReleaseFrame(media::VideoFrame* frame) {
   DCHECK(CurrentlyOnPluginThread());
 
   if (frame) {
-    instance_->Log(logging::LOG_WARNING, "Frame released.");
+    LOG(WARNING) << "Frame released.";
     frame->Release();
   }
 }
 
 void PepperView::OnPartialFrameOutput(media::VideoFrame* frame,
                                       UpdatedRects* rects,
                                       Task* done) {
   DCHECK(CurrentlyOnPluginThread());
 
   TraceContext::tracer()->PrintString("Calling PaintFrame");
@@ skipping 11 matching lines @@
       (base::Time::Now() - paint_start).InMilliseconds());
 
   // If the last flush failed because there was already another one in progress
   // then we perform the flush now.
   if (pending_flush_)
     FlushGraphics(base::Time::Now());
   return;
 }
 
 }  // namespace remoting