Coverity: Initialize member variables.

chrome/gpu/gpu_command_buffer_stub.cc

 // Copyright (c) 2010 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.
 
 #if defined(ENABLE_GPU)
 
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "build/build_config.h"
 #include "chrome/common/child_thread.h"
 #include "chrome/common/gpu_messages.h"
 #include "chrome/gpu/gpu_channel.h"
 #include "chrome/gpu/gpu_command_buffer_stub.h"
 
 using gpu::Buffer;
 
 #if defined(OS_WIN)
 #define kCompositorWindowOwner L"CompositorWindowOwner"
-#endif
+#endif  // defined(OS_WIN)
 
 GpuCommandBufferStub::GpuCommandBufferStub(
     GpuChannel* channel,
     gfx::PluginWindowHandle handle,
     GpuCommandBufferStub* parent,
     const gfx::Size& size,
     const std::string& allowed_extensions,
     const std::vector<int32>& attribs,
     uint32 parent_texture_id,
     int32 route_id,
     int32 renderer_id,
     int32 render_view_id)
     : channel_(channel),
       handle_(handle),
       parent_(
           parent ? parent->AsWeakPtr() : base::WeakPtr<GpuCommandBufferStub>()),
       initial_size_(size),
       allowed_extensions_(allowed_extensions),
       requested_attribs_(attribs),
       parent_texture_id_(parent_texture_id),
       route_id_(route_id),
+#if defined(OS_WIN)
+      compositor_window_(NULL),
+#endif  // defined(OS_WIN)
       renderer_id_(renderer_id),
       render_view_id_(render_view_id) {
 }
 
 #if defined(OS_WIN)
 static LRESULT CALLBACK CompositorWindowProc(
     HWND hwnd,
     UINT message,
     WPARAM wparam,
     LPARAM lparam) {
@@ skipping 105 matching lines @@
   }
 #if defined(OS_WIN)
   if (compositor_window_) {
     DestroyWindow(static_cast<HWND>(compositor_window_));
     compositor_window_ = NULL;
   }
 #elif defined(OS_LINUX)
   ChildThread* gpu_thread = ChildThread::current();
   gpu_thread->Send(
       new GpuHostMsg_ReleaseXID(handle_));
-#endif
+#endif  // defined(OS_WIN)
 }
 
 void GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Initialize, OnInitialize);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_GetState, OnGetState);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncGetState, OnAsyncGetState);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Flush, OnFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateTransferBuffer,
                         OnCreateTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyTransferBuffer,
                         OnDestroyTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_GetTransferBuffer,
                         OnGetTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_ResizeOffscreenFrameBuffer,
                         OnResizeOffscreenFrameBuffer);
 #if defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SetWindowSize, OnSetWindowSize);
-#endif
+#endif  // defined(OS_MACOSX)
     IPC_MESSAGE_UNHANDLED_ERROR()
   IPC_END_MESSAGE_MAP()
 }
 
 bool GpuCommandBufferStub::Send(IPC::Message* message) {
   return channel_->Send(message);
 }
 
 void GpuCommandBufferStub::OnInitialize(
     int32 size,
@@ skipping 10 matching lines @@
   if (handle_) {
     if (!CreateCompositorWindow()) {
       return;
     }
     output_window_handle = compositor_window_;
   } else {
     output_window_handle = handle_;
   }
 #else
   gfx::PluginWindowHandle output_window_handle = handle_;
-#endif
+#endif  // defined(OS_WIN)
 
   // Initialize the CommandBufferService and GPUProcessor.
   if (command_buffer_->Initialize(size)) {
     Buffer buffer = command_buffer_->GetRingBuffer();
     if (buffer.shared_memory) {
       gpu::GPUProcessor* parent_processor =
           parent_ ? parent_->processor_.get() : NULL;
       processor_.reset(new gpu::GPUProcessor(command_buffer_.get(), NULL));
       if (processor_->Initialize(
           output_window_handle,
@@ skipping 23 matching lines @@
                           &GpuCommandBufferStub::SwapBuffersCallback));
         }
 #elif defined(OS_LINUX) || defined(OS_WIN)
         if (handle_) {
           // Set up a pathway for resizing the output window at the right time
           // relative to other GL commands.
           processor_->SetResizeCallback(
               NewCallback(this,
                           &GpuCommandBufferStub::ResizeCallback));
         }
-#endif
+#endif  // defined(OS_MACOSX)
       } else {
         processor_.reset();
         command_buffer_.reset();
       }
     }
   }
 }
 
 void GpuCommandBufferStub::OnGetState(gpu::CommandBuffer::State* state) {
   *state = command_buffer_->GetState();
@@ skipping 73 matching lines @@
   OnSwapBuffers();
   ChildThread* gpu_thread = ChildThread::current();
   GpuHostMsg_AcceleratedSurfaceBuffersSwapped_Params params;
   params.renderer_id = renderer_id_;
   params.render_view_id = render_view_id_;
   params.window = handle_;
   params.surface_id = processor_->GetSurfaceId();
   params.route_id = route_id();
 #if defined(OS_MACOSX)
   params.swap_buffers_count = processor_->swap_buffers_count();
-#endif
+#endif  // defined(OS_MACOSX)
   gpu_thread->Send(new GpuHostMsg_AcceleratedSurfaceBuffersSwapped(params));
 }
 
 void GpuCommandBufferStub::AcceleratedSurfaceBuffersSwapped(
     uint64 swap_buffers_count) {
   processor_->set_acknowledged_swap_buffers_count(swap_buffers_count);
   // Wake up the GpuProcessor to start doing work again.
   processor_->ScheduleProcessCommands();
 }
 #endif  // defined(OS_MACOSX)
 
 void GpuCommandBufferStub::ResizeCallback(gfx::Size size) {
   if (handle_ == gfx::kNullPluginWindow)
     return;
 
 #if defined(OS_LINUX)
   ChildThread* gpu_thread = ChildThread::current();
   bool result = false;
   gpu_thread->Send(
       new GpuHostMsg_ResizeXID(handle_, size, &result));
 #elif defined(OS_WIN)
   HWND hwnd = static_cast<HWND>(compositor_window_);
   UINT swp_flags = SWP_NOSENDCHANGING | SWP_NOOWNERZORDER | SWP_NOCOPYBITS |
     SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE | SWP_DEFERERASE;
   SetWindowPos(hwnd, NULL, 0, 0, size.width(), size.height(), swp_flags);
-#endif
+#endif  // defined(OS_LINUX)
 }
 
-#endif  // ENABLE_GPU
+#endif  // defined(ENABLE_GPU)