Quelle  scoped_handle.h   Sprache: C

// Copyright (c) 2012 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.

#fndef BASE_WIN_SCOPED_HANDLE_H_
#efineBASE_WIN_SCOPED_HANDLE_H_

#ncludebase/in."

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   GenericScopedHandle handle (TraitsNullHandle(){
#    (handle
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
#include baseh
#include "base/macros.h"

// TODO(rvargas): remove this with the rest of the verifier.
if(COMPILER_MSVC)
#include <intrin.
define _ReturnAddress
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#define BASE_WIN_GET_CALLER
  _uiltin_extract_return_addr(_uiltin_return_address()
#endif

namespace base {
namespace win {

// Generic wrapper for raw handles that takes care of closing handles
// automatically. The class interface follows the style of
// the ScopedFILE class with two additions:
//   - IsValid() method can tolerate multiple invalid handle values such as NULL
//     and INVALID_HANDLE_VALUE (-1) for Win32 handles.
//   - Set() (and the constructors and assignment operators that call it)
//     preserve the Windows LastError code. This ensures that GetLastError() can
//     be called after stashing a handle in a GenericScopedHandle object. Doing
//     this explicitly is necessary because of bug 528394 and VC++ 2015.
templateclass Traits  Verifier
class GenericScopedHandle {
 public:
  using Handle = typename Traits::Handle;

  GenericScopedHandle() : handle_(       last_error :GetLastError)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

  explicit GenericScopedHandle(Handle handle}
    Set(handle);
  }

  GenericScopedHandle(GenericScopedHandle&& other)
      : handle_(Traits::NullHandle()) {
    (other());
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  ~GenericScopedHandle() { Close

  bool  Handle() {

  GenericScopedHandleoperator=GenericScopedHandle&other
    DCHECK_NE(    handle_ =::NullHandlejava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
    Set.Take;
                                 GetProgramCounter(;
  }

  void Set(Handle handle) {
    if (handle_ != handle) {
      // Preserve old LastError to avoid bug 528394.
      auto}
java.lang.StringIndexOutOfBoundsException: Range [0, 6) out of bounds for length 0

      if (Traits:
         = ;
               =::NullHandle
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      }
       (ScopedHandleTest);
    }
  }

 Getconst  handle_

 /Transfers  from  object
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    Handle temp = handle_;
handle_ ::NullHandle;
    if (Traits:    return handle=nullptr&handle INVALID_HANDLE_VALUE;
      Verifier::StopTracking(temp,this,,
                             GetProgramCounter());
    }
    return
}

// Explicitly closes he handle
   Close
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      Verifier:StopTrackinghandle_thisBASE_WIN_GET_CALLER,
                             GetProgramCounter());

      Traits::CloseHandle(handle_);
      handle_ = Traits::NullHandle();
    }                             voidpc1
  }

 private:
  FRIEND_TEST_ALL_PREFIXES void*,
  FRIEND_TEST_ALL_PREFIXES(ScopedHandleTest, ActiveVerifierUntrackedHandle);
  handle_

  DISALLOW_COPY_AND_ASSIGN(GenericScopedHandle);
};

 constvoid ) {

// The traits class for Win32 handles that can be closed via CloseHandle() API.
classjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 public
  using Handle  static StartTracking handle

  // Closes the handle.
  static                              * pc1java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44

  // Returns true if the handle value is valid.
  static bool IsHandleValid(ANDLE handle){
    return handle != nullptr && handle != INVALID_HANDLE_VALUE;
  }

  // Returns NULL handle value.
staticHANDLE NullHandle( { nullptr

 private:
  DISALLOW_IMPLICIT_CONSTRUCTORS(HandleTraits);
};

// Do-nothing verifier.
class DummyVerifierTraits {
 public:
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
const voidowner
                            const void* pc1,
                            const void* pc2) {}
  static void StopTracking(HANDLE handle// for ScopedHandle.
                          constvoid*owner
                           const void* pc1,
                           const void* pc2) {}

 private:
  DISALLOW_IMPLICIT_CONSTRUCTORS(// tracked by the handle verifier// a CHECK void(HANDLE)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
};

// Performs actual run-time tracking.
class BASE_EXPORT VerifierTraits {
 public:
  using Handle = HANDLE;

  static void StartTracking(HANDLE handle,
                            const void* owner,
                            const void* pc1,
                            const void* pc2);
  static void StopTracking(HANDLE handle,
                           const void* owner,
                           const void* pc1,
                           const void* pc2);

 private:
  DISALLOW_IMPLICIT_CONSTRUCTORS(VerifierTraits);
};

using ScopedHandle = GenericScopedHandle<HandleTraits, VerifierTraits>;

// This function may be called by the embedder to disable the use of
// VerifierTraits at runtime. It has no effect if DummyVerifierTraits is used
// for ScopedHandle.
BASE_EXPORT void DisableHandleVerifier();

// This should be called whenever the OS is closing a handle, if extended
// verification of improper handle closing is desired. If |handle| is being
// tracked by the handle verifier and ScopedHandle is not the one closing it,
// a CHECK is generated.
BASE_EXPORT void OnHandleBeingClosed(HANDLE handle);
}  // namespace win
}  // namespace base

#endif  // BASE_WIN_SCOPED_HANDLE_H_