[svn-r18837] Description:

	Remove the size parameter from H5[A]C_unprotect() and the
H5[A]C__SIZE_CHANGED_FLAG, switching all clients & tests over to using
H5[A]C_resize_entry appropriately.

Tested on:
        FreeBSD/32 6.3 (duty) in debug mode
        FreeBSD/64 6.3 (liberty) w/C++ & FORTRAN, in debug mode
        Linux/32 2.6 (jam) w/PGI compilers, w/default API=1.8.x,
                w/C++ & FORTRAN, w/threadsafe, in debug mode
        Linux/64-amd64 2.6 (amani) w/Intel compilers, w/default API=1.6.x,
                w/C++ & FORTRAN, in production mode
        Solaris/32 2.10 (linew) w/deprecated symbols disabled, w/C++ & FORTRAN,
                w/szip filter, in production mode
        Linux/64-ia64 2.6 (cobalt) w/Intel compilers, w/C++ & FORTRAN,
                in production mode
        Linux/64-amd64 2.6 (abe) w/parallel, w/FORTRAN, in production mode
        Mac OS X/32 10.6.3 (amazon) in debug mode
        Mac OS X/32 10.6.3 (amazon) w/C++ & FORTRAN, w/threadsafe,
                in production mode

14 files changed, 213 insertions, 255 deletions

diff --git a/src/H5AC.c b/src/H5AC.c
index 63a9cb2..fe69703 100644
--- a/src/H5AC.c
+++ b/src/H5AC.c
@@ -155,9 +155,7 @@ static herr_t H5AC_log_deleted_entry(H5AC_t * cache_ptr,
                                      unsigned int flags);
 
 static herr_t H5AC_log_dirtied_entry(const H5AC_info_t * entry_ptr,
-                                     haddr_t addr,
-                                     hbool_t size_changed,
-                                     size_t new_size);
+                                     haddr_t addr);
 
 static herr_t H5AC_log_flushed_entry(H5C_t * cache_ptr,
                                      haddr_t addr,
@@ -1290,7 +1288,7 @@ H5AC_mark_entry_dirty(void *thing)
 
     if((!entry_ptr->is_dirty) && (!entry_ptr->is_protected) &&
              (entry_ptr->is_pinned) && (NULL != cache_ptr->aux_ptr)) {
-        if(H5AC_log_dirtied_entry(entry_ptr, entry_ptr->addr, FALSE, 0) < 0)
+        if(H5AC_log_dirtied_entry(entry_ptr, entry_ptr->addr) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, "can't log dirtied entry")
     } /* end if */
 }
@@ -1731,6 +1729,9 @@ H5AC_resize_entry(void *thing, size_t new_size)
 		(int)new_size);
 #endif /* H5AC__TRACE_FILE_ENABLED */
 
+    if(H5C_resize_entry(thing, new_size) < 0)
+        HGOTO_ERROR(H5E_CACHE, H5E_CANTRESIZE, FAIL, "can't resize entry")
+
 #ifdef H5_HAVE_PARALLEL
 {
     H5AC_info_t * entry_ptr = (H5AC_info_t *)thing;
@@ -1740,19 +1741,12 @@ H5AC_resize_entry(void *thing, size_t new_size)
     HDassert(cache_ptr->magic == H5C__H5C_T_MAGIC);
 
     if((!entry_ptr->is_dirty) && (NULL != cache_ptr->aux_ptr)) {
-        /* Check for usage errors */
-        if(!(entry_ptr->is_pinned || entry_ptr->is_protected))
-            HGOTO_ERROR(H5E_CACHE, H5E_CANTRESIZE, FAIL, "Entry isn't pinned or protected??")
-
-        if(H5AC_log_dirtied_entry(entry_ptr, entry_ptr->addr, TRUE, new_size) < 0)
+        if(H5AC_log_dirtied_entry(entry_ptr, entry_ptr->addr) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTMARKDIRTY, FAIL, "can't log dirtied entry")
     } /* end if */
 }
 #endif /* H5_HAVE_PARALLEL */
 
-    if(H5C_resize_entry(thing, new_size) < 0)
-        HGOTO_ERROR(H5E_CACHE, H5E_CANTRESIZE, FAIL, "can't resize entry")
-
 done:
 #if H5AC__TRACE_FILE_ENABLED
     if(trace_file_ptr)
@@ -1958,7 +1952,7 @@ H5AC_unprotect(H5F_t *f, hid_t dxpl_id, const H5AC_class_t *type, haddr_t addr,
 {
     herr_t		result;
     hbool_t		dirtied;
-    size_t		new_size = 0;
+    hbool_t		deleted;
 #ifdef H5_HAVE_PARALLEL
     hbool_t		size_changed = FALSE;
     H5AC_aux_t        * aux_ptr = NULL;
@@ -2005,32 +1999,28 @@ H5AC_unprotect(H5F_t *f, hid_t dxpl_id, const H5AC_class_t *type, haddr_t addr,
 
     dirtied = (hbool_t)( ( (flags & H5AC__DIRTIED_FLAG) == H5AC__DIRTIED_FLAG ) ||
 		( ((H5AC_info_t *)thing)->dirtied ) );
+    deleted = (hbool_t)( (flags & H5C__DELETED_FLAG) == H5C__DELETED_FLAG );
 
-    if ( dirtied ) {
+    /* Check if the size changed out from underneath us, if we're not deleting
+     *  the entry.
+     */
+    if ( dirtied && !deleted ) {
+        size_t		curr_size = 0;
 
-        if ( (type->size)(f, thing, &new_size) < 0 ) {
+        if ( (type->size)(f, thing, &curr_size) < 0 ) {
 
             HGOTO_ERROR(H5E_RESOURCE, H5E_CANTGETSIZE, FAIL, \
                         "Can't get size of thing")
         }
 
-        if ( ((H5AC_info_t *)thing)->size != new_size ) {
-
-#ifdef H5_HAVE_PARALLEL
-            size_changed = TRUE;
-#endif /* H5_HAVE_PARALLEL */
-            flags = flags | H5AC__SIZE_CHANGED_FLAG;
-#if H5AC__TRACE_FILE_ENABLED
-	    trace_flags = flags;
-	    trace_new_size = new_size;
-#endif /* H5AC__TRACE_FILE_ENABLED */
-        }
+        if(((H5AC_info_t *)thing)->size != curr_size)
+            HGOTO_ERROR(H5E_CACHE, H5E_BADSIZE, FAIL, "size of entry changed")
     }
 
 #ifdef H5_HAVE_PARALLEL
     if ( ( dirtied ) && ( ((H5AC_info_t *)thing)->is_dirty == FALSE ) &&
          ( NULL != (aux_ptr = f->shared->cache->aux_ptr) ) ) {
-        if(H5AC_log_dirtied_entry((H5AC_info_t *)thing, addr, size_changed, new_size) < 0)
+        if(H5AC_log_dirtied_entry((H5AC_info_t *)thing, addr) < 0)
             HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, "can't log dirtied entry")
     }
 
@@ -2057,8 +2047,7 @@ H5AC_unprotect(H5F_t *f, hid_t dxpl_id, const H5AC_class_t *type, haddr_t addr,
                            type,
                            addr,
                            thing,
-                           flags,
-                           new_size);
+                           flags);
 
     if ( result < 0 ) {
 
@@ -3476,9 +3465,7 @@ done:
 #ifdef H5_HAVE_PARALLEL
 static herr_t
 H5AC_log_dirtied_entry(const H5AC_info_t * entry_ptr,
-                       haddr_t addr,
-                       hbool_t size_changed,
-                       size_t new_size)
+                       haddr_t addr)
 {
     size_t		 entry_size;
     H5AC_t             * cache_ptr;
@@ -3501,14 +3488,7 @@ H5AC_log_dirtied_entry(const H5AC_info_t * entry_ptr,
     HDassert( aux_ptr != NULL );
     HDassert( aux_ptr->magic == H5AC__H5AC_AUX_T_MAGIC );
 
-    if ( size_changed ) {
-
-        entry_size = new_size;
-
-    } else {
-
-        entry_size = entry_ptr->size;
-    }
+    entry_size = entry_ptr->size;
 
     if ( aux_ptr->mpi_rank == 0 ) {
         H5AC_slist_entry_t * slist_entry_ptr;
diff --git a/src/H5ACprivate.h b/src/H5ACprivate.h
index fab15fc..5763e14 100644
--- a/src/H5ACprivate.h
+++ b/src/H5ACprivate.h
@@ -294,7 +294,6 @@ extern hid_t H5AC_ind_dxpl_id;
 #define H5AC__SET_FLUSH_MARKER_FLAG	  H5C__SET_FLUSH_MARKER_FLAG
 #define H5AC__DELETED_FLAG		  H5C__DELETED_FLAG
 #define H5AC__DIRTIED_FLAG		  H5C__DIRTIED_FLAG
-#define H5AC__SIZE_CHANGED_FLAG		  H5C__SIZE_CHANGED_FLAG
 #define H5AC__PIN_ENTRY_FLAG		  H5C__PIN_ENTRY_FLAG
 #define H5AC__UNPIN_ENTRY_FLAG		  H5C__UNPIN_ENTRY_FLAG
 #define H5AC__FLUSH_INVALIDATE_FLAG	  H5C__FLUSH_INVALIDATE_FLAG
diff --git a/src/H5C.c b/src/H5C.c
index 6c1b18f..6f88b5e 100644
--- a/src/H5C.c
+++ b/src/H5C.c
@@ -5074,14 +5074,12 @@ H5C_unprotect(H5F_t *		  f,
               const H5C_class_t * type,
               haddr_t		  addr,
               void *		  thing,
-              unsigned int        flags,
-              size_t              new_size)
+              unsigned int        flags)
 {
     H5C_t *		cache_ptr;
     hbool_t		deleted;
     hbool_t		dirtied;
     hbool_t             set_flush_marker;
-    hbool_t		size_changed;
     hbool_t		pin_entry;
     hbool_t		unpin_entry;
     hbool_t		free_file_space;
@@ -5101,18 +5099,11 @@ H5C_unprotect(H5F_t *		  f,
     deleted          = ( (flags & H5C__DELETED_FLAG) != 0 );
     dirtied          = ( (flags & H5C__DIRTIED_FLAG) != 0 );
     set_flush_marker = ( (flags & H5C__SET_FLUSH_MARKER_FLAG) != 0 );
-    size_changed     = ( (flags & H5C__SIZE_CHANGED_FLAG) != 0 );
     pin_entry        = ( (flags & H5C__PIN_ENTRY_FLAG) != 0 );
     unpin_entry      = ( (flags & H5C__UNPIN_ENTRY_FLAG) != 0 );
     free_file_space  = ( (flags & H5C__FREE_FILE_SPACE_FLAG) != 0 );
     take_ownership   = ( (flags & H5C__TAKE_OWNERSHIP_FLAG) != 0 );
 
-    /* Changing the size of an entry dirties it.  Thus, set the
-     * dirtied flag if the size_changed flag is set.
-     */
-
-    dirtied |= size_changed;
-
     HDassert( f );
     HDassert( f->shared );
 
@@ -5126,9 +5117,6 @@ H5C_unprotect(H5F_t *		  f,
     HDassert( type->flush );
     HDassert( H5F_addr_defined(addr) );
     HDassert( thing );
-    HDassert( ( size_changed == TRUE ) || ( size_changed == FALSE ) );
-    HDassert( ( ! size_changed ) || ( dirtied ) );
-    HDassert( ( ! size_changed ) || ( new_size > 0 ) );
     HDassert( ! ( pin_entry && unpin_entry ) );
     HDassert( ( ! free_file_space ) || ( deleted ) );   /* deleted flag must accompany free_file_space */
     HDassert( ( ! take_ownership ) || ( deleted ) );    /* deleted flag must accompany take_ownership */
@@ -5240,58 +5228,7 @@ H5C_unprotect(H5F_t *		  f,
         /* mark the entry as dirty if appropriate */
         entry_ptr->is_dirty = ( (entry_ptr->is_dirty) || dirtied );
 
-        /* update for change in entry size if necessary */
-        if ( ( size_changed ) && ( entry_ptr->size != new_size ) ) {
-
-            /* do a flash cache size increase if appropriate */
-            if ( cache_ptr->flash_size_increase_possible ) {
-
-                if ( new_size > entry_ptr->size ) {
-
-                    size_increase = new_size - entry_ptr->size;
-
-                    if ( size_increase >=
-                         cache_ptr->flash_size_increase_threshold ) {
-
-                        result = H5C__flash_increase_cache_size(cache_ptr,
-                                                              entry_ptr->size,
-                                                              new_size);
-
-                        if ( result < 0 ) {
-
-                            HGOTO_ERROR(H5E_CACHE, H5E_CANTUNPROTECT, FAIL, \
-                                     "H5C__flash_increase_cache_size failed.")
-                        }
-                    }
-                }
-            }
-
-            /* update the protected list */
-            H5C__DLL_UPDATE_FOR_SIZE_CHANGE((cache_ptr->pl_len), \
-                                            (cache_ptr->pl_size), \
-                                            (entry_ptr->size), (new_size));
-
-            /* update the hash table */
-	    H5C__UPDATE_INDEX_FOR_SIZE_CHANGE((cache_ptr), (entry_ptr->size), \
-                                              (new_size), (entry_ptr), \
-					      (was_clean));
-
-            /* if the entry is in the skip list, update that too */
-            if ( entry_ptr->in_slist ) {
-
-	        H5C__UPDATE_SLIST_FOR_SIZE_CHANGE((cache_ptr), \
-				                  (entry_ptr->size),\
-                                                  (new_size));
-            }
-
-            /* update statistics just before changing the entry size */
-	    H5C__UPDATE_STATS_FOR_ENTRY_SIZE_CHANGE((cache_ptr), (entry_ptr), \
-                                                    (new_size));
-
-	    /* finally, update the entry size proper */
-	    entry_ptr->size = new_size;
-
-        } else if ( ( was_clean ) && ( entry_ptr->is_dirty ) ) {
+        if ( ( was_clean ) && ( entry_ptr->is_dirty ) ) {
 
 	    H5C__UPDATE_INDEX_FOR_ENTRY_DIRTY(cache_ptr, entry_ptr)
 	}
diff --git a/src/H5Cprivate.h b/src/H5Cprivate.h
index 361d70b..0441213 100644
--- a/src/H5Cprivate.h
+++ b/src/H5Cprivate.h
@@ -993,7 +993,6 @@ typedef struct H5C_auto_size_ctl_t
  * 	H5C__SET_FLUSH_MARKER_FLAG
  * 	H5C__DELETED_FLAG
  * 	H5C__DIRTIED_FLAG
- * 	H5C__SIZE_CHANGED_FLAG
  * 	H5C__PIN_ENTRY_FLAG
  * 	H5C__UNPIN_ENTRY_FLAG
  * 	H5C__FREE_FILE_SPACE_FLAG
@@ -1023,14 +1022,13 @@ typedef struct H5C_auto_size_ctl_t
 #define H5C__SET_FLUSH_MARKER_FLAG		0x0001
 #define H5C__DELETED_FLAG			0x0002
 #define H5C__DIRTIED_FLAG			0x0004
-#define H5C__SIZE_CHANGED_FLAG			0x0008
-#define H5C__PIN_ENTRY_FLAG			0x0010
-#define H5C__UNPIN_ENTRY_FLAG			0x0020
-#define H5C__FLUSH_INVALIDATE_FLAG		0x0040
-#define H5C__FLUSH_CLEAR_ONLY_FLAG		0x0080
-#define H5C__FLUSH_MARKED_ENTRIES_FLAG		0x0100
-#define H5C__FLUSH_IGNORE_PROTECTED_FLAG	0x0200
-#define H5C__READ_ONLY_FLAG			0x0400
+#define H5C__PIN_ENTRY_FLAG			0x0008
+#define H5C__UNPIN_ENTRY_FLAG			0x0010
+#define H5C__FLUSH_INVALIDATE_FLAG		0x0020
+#define H5C__FLUSH_CLEAR_ONLY_FLAG		0x0040
+#define H5C__FLUSH_MARKED_ENTRIES_FLAG		0x0080
+#define H5C__FLUSH_IGNORE_PROTECTED_FLAG	0x0100
+#define H5C__READ_ONLY_FLAG			0x0200
 #define H5C__FREE_FILE_SPACE_FLAG		0x0800
 #define H5C__TAKE_OWNERSHIP_FLAG		0x1000
 
@@ -1170,8 +1168,7 @@ H5_DLL herr_t H5C_unprotect(H5F_t *             f,
                             const H5C_class_t * type,
                             haddr_t             addr,
                             void *              thing,
-                            unsigned int        flags,
-                            size_t              new_size);
+                            unsigned int        flags);
 
 H5_DLL herr_t H5C_validate_resize_config(H5C_auto_size_ctl_t * config_ptr,
                                          unsigned int tests);
diff --git a/src/H5FSsection.c b/src/H5FSsection.c
index 7c0ab72..5ad6233 100644
--- a/src/H5FSsection.c
+++ b/src/H5FSsection.c
@@ -367,7 +367,7 @@ HDfprintf(stderr, "%s: fspace->alloc_sect_size = %Hu, fspace->sect_size = %Hu\n"
 
                 /* Check if the section info size in the file has changed */
                 if(fspace->sect_size != fspace->alloc_sect_size)
-                    cache_flags |= H5AC__SIZE_CHANGED_FLAG | H5AC__DELETED_FLAG | H5AC__TAKE_OWNERSHIP_FLAG;
+                    cache_flags |= H5AC__DELETED_FLAG | H5AC__TAKE_OWNERSHIP_FLAG;
             } /* end if */
 
             /* Sanity check */
diff --git a/src/H5HG.c b/src/H5HG.c
index 99ffb50..032ca63 100644
--- a/src/H5HG.c
+++ b/src/H5HG.c
@@ -99,7 +99,7 @@ static haddr_t H5HG_create(H5F_t *f, hid_t dxpl_id, size_t size);
 /* Package Variables */
 /*********************/
 
-/* Declare a free list to manage the H5HG_t struct */
+/* Declare a free list to manage the H5HG_heap_t struct */
 H5FL_DEFINE(H5HG_heap_t);
 
 /* Declare a free list to manage sequences of H5HG_obj_t's */
@@ -264,7 +264,7 @@ done:
  *
  *-------------------------------------------------------------------------
  */
-H5HG_t *
+H5HG_heap_t *
 H5HG_protect(H5F_t *f, hid_t dxpl_id, haddr_t addr, H5AC_protect_t rw)
 {
     H5HG_heap_t *heap;          /* Global heap */
@@ -310,36 +310,36 @@ done:
  *-------------------------------------------------------------------------
  */
 static size_t
-H5HG_alloc (H5F_t *f, H5HG_heap_t *heap, size_t size, unsigned * heap_flags_ptr)
+H5HG_alloc(H5F_t *f, H5HG_heap_t *heap, size_t size, unsigned *heap_flags_ptr)
 {
     size_t	idx;
-    uint8_t	*p = NULL;
+    uint8_t	*p;
     size_t	need = H5HG_SIZEOF_OBJHDR(f) + H5HG_ALIGN(size);
-    size_t ret_value;         /* Return value */
+    size_t      ret_value;         /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5HG_alloc);
 
     /* Check args */
-    assert (heap);
-    assert (heap->obj[0].size>=need);
-    assert (heap_flags_ptr);
+    HDassert(heap);
+    HDassert(heap->obj[0].size>=need);
+    HDassert(heap_flags_ptr);
 
     /*
      * Find an ID for the new object. ID zero is reserved for the free space
      * object.
      */
-    if(heap->nused<=H5HG_MAXIDX)
-        idx=heap->nused++;
+    if(heap->nused <= H5HG_MAXIDX)
+        idx = heap->nused++;
     else {
-        for (idx=1; idx<heap->nused; idx++)
-            if (NULL==heap->obj[idx].begin)
+        for(idx = 1; idx < heap->nused; idx++)
+            if(NULL == heap->obj[idx].begin)
                 break;
     } /* end else */
 
     HDassert(idx < heap->nused);
 
     /* Check if we need more room to store heap objects */
-    if(idx>=heap->nalloc) {
+    if(idx >= heap->nalloc) {
         size_t new_alloc;       /* New allocation number */
         H5HG_obj_t *new_obj;	/* New array of object descriptions */
 
@@ -349,16 +349,16 @@ H5HG_alloc (H5F_t *f, H5HG_heap_t *heap, size_t size, unsigned * heap_flags_ptr)
         HDassert(idx < new_alloc);
 
         /* Reallocate array of objects */
-        if (NULL==(new_obj = H5FL_SEQ_REALLOC (H5HG_obj_t, heap->obj, new_alloc)))
-            HGOTO_ERROR(H5E_RESOURCE, H5E_NOSPACE, 0, "memory allocation failed")
+        if(NULL == (new_obj = H5FL_SEQ_REALLOC(H5HG_obj_t, heap->obj, new_alloc)))
+            HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, 0, "memory allocation failed")
 
         /* Clear newly allocated space */
         HDmemset(&new_obj[heap->nalloc], 0, (new_alloc - heap->nalloc) * sizeof(heap->obj[0]));
 
         /* Update heap information */
-        heap->nalloc=new_alloc;
-        heap->obj=new_obj;
-        HDassert(heap->nalloc>heap->nused);
+        heap->nalloc = new_alloc;
+        heap->obj = new_obj;
+        HDassert(heap->nalloc > heap->nused);
     } /* end if */
 
     /* Initialize the new object */
@@ -372,14 +372,14 @@ H5HG_alloc (H5F_t *f, H5HG_heap_t *heap, size_t size, unsigned * heap_flags_ptr)
     H5F_ENCODE_LENGTH (f, p, size);
 
     /* Fix the free space object */
-    if (need==heap->obj[0].size) {
+    if(need == heap->obj[0].size) {
 	/*
 	 * All free space has been exhausted from this collection.
 	 */
 	heap->obj[0].size = 0;
 	heap->obj[0].begin = NULL;
-
-    } else if (heap->obj[0].size-need >= H5HG_SIZEOF_OBJHDR (f)) {
+    } /* end if */
+    else if(heap->obj[0].size-need >= H5HG_SIZEOF_OBJHDR (f)) {
 	/*
 	 * Some free space remains and it's larger than a heap object header,
 	 * so write the new free heap object header to the heap.
@@ -392,8 +392,8 @@ H5HG_alloc (H5F_t *f, H5HG_heap_t *heap, size_t size, unsigned * heap_flags_ptr)
 	UINT32ENCODE(p, 0);	/*reserved*/
 	H5F_ENCODE_LENGTH (f, p, heap->obj[0].size);
 	assert(H5HG_ISALIGNED(heap->obj[0].size));
-
-    } else {
+    } /* end else-if */
+    else {
 	/*
 	 * Some free space remains but it's smaller than a heap object header,
 	 * so we don't write the header.
@@ -407,11 +407,11 @@ H5HG_alloc (H5F_t *f, H5HG_heap_t *heap, size_t size, unsigned * heap_flags_ptr)
     *heap_flags_ptr |= H5AC__DIRTIED_FLAG;
 
     /* Set the return value */
-    ret_value=idx;
+    ret_value = idx;
 
 done:
     FUNC_LEAVE_NOAPI(ret_value);
-}
+} /* end H5HG_alloc() */
 
 
 /*-------------------------------------------------------------------------
@@ -442,11 +442,13 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5HG_extend(H5F_t *f, H5HG_heap_t *heap, size_t need, unsigned *heap_flags_ptr)
+H5HG_extend(H5F_t *f, hid_t dxpl_id, haddr_t addr, size_t need)
 {
+    H5HG_heap_t *heap = NULL;       /* Pointer to heap to extend */
+    unsigned heap_flags = H5AC__NO_FLAGS_SET;   /* Flags to unprotecting heap */
     size_t  old_size;               /* Previous size of the heap's chunk */
-    uint8_t *new_chunk = NULL;      /* Pointer to new chunk information */
-    uint8_t *p = NULL;              /* Pointer to raw heap info */
+    uint8_t *new_chunk;             /* Pointer to new chunk information */
+    uint8_t *p;                     /* Pointer to raw heap info */
     unsigned u;                     /* Local index variable */
     herr_t  ret_value = SUCCEED;    /* Return value */
 
@@ -454,8 +456,11 @@ H5HG_extend(H5F_t *f, H5HG_heap_t *heap, size_t need, unsigned *heap_flags_ptr)
 
     /* Check args */
     HDassert(f);
-    HDassert(heap);
-    HDassert(heap_flags_ptr);
+    HDassert(H5F_addr_defined(addr));
+
+    /* Protect the heap */
+    if(NULL == (heap = H5HG_protect(f, dxpl_id, addr, H5AC_WRITE)))
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to protect global heap")
 
     /* Re-allocate the heap information in memory */
     if(NULL == (new_chunk = H5FL_BLK_REALLOC(gheap_chunk, heap->chunk, (heap->size + need))))
@@ -491,10 +496,17 @@ HDmemset(new_chunk + heap->size, 0, need);
     H5F_ENCODE_LENGTH(f, p, heap->obj[0].size);
     assert(H5HG_ISALIGNED(heap->obj[0].size));
 
+    /* Resize the heap in the cache */
+    if(H5AC_resize_entry(heap, heap->size) < 0)
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, FAIL, "unable to resize global heap in cache")
+
     /* Mark the heap as dirty */
-    *heap_flags_ptr |= H5AC__DIRTIED_FLAG;
+    heap_flags |= H5AC__DIRTIED_FLAG;
 
 done:
+    if(heap && H5AC_unprotect(f, dxpl_id, H5AC_GHEAP, heap->addr, heap, heap_flags) < 0)
+        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to unprotect heap")
+
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5HG_extend() */
 
@@ -560,14 +572,6 @@ H5HG_insert(H5F_t *f, hid_t dxpl_id, size_t size, void *obj, H5HG_t *hobj/*out*/
      * and protecting and unprotecting all the collections in the global
      * heap on a regular basis will skew the replacement policy.
      *
-     * However, there is a bigger issue -- as best I can tell, we only look
-     * for free space in global heap chunks that are in cache.  If we can't
-     * find any, we allocate a new chunk.  This may be a problem in FP mode,
-     * as the metadata cache is disabled.  Do we allocate a new heap
-     * collection for every entry in this case?
-     *
-     * Note that all this comes from a cursory read of the source.  Don't
-     * take any of it as gospel.
      *                                        JRM - 5/24/04
      */
     for(cwfsno = 0; cwfsno < f->shared->ncwfs; cwfsno++)
@@ -596,8 +600,8 @@ H5HG_insert(H5F_t *f, hid_t dxpl_id, size_t size, void *obj, H5HG_t *hobj/*out*/
                 if(extended < 0)
                     HGOTO_ERROR(H5E_HEAP, H5E_CANTEXTEND, FAIL, "error trying to extend heap")
                 else if(extended == TRUE) {
-                    if(H5HG_extend(f, f->shared->cwfs[cwfsno], new_need, &heap_flags) < 0)
-                        HGOTO_ERROR(H5E_HEAP, H5E_CANTINIT, FAIL, "unable to extend global heap collection")
+                    if(H5HG_extend(f, dxpl_id, f->shared->cwfs[cwfsno]->addr, new_need) < 0)
+                        HGOTO_ERROR(H5E_HEAP, H5E_CANTRESIZE, FAIL, "unable to extend global heap collection")
                     addr = f->shared->cwfs[cwfsno]->addr;
                     found = TRUE;
                     break;
@@ -633,7 +637,8 @@ H5HG_insert(H5F_t *f, hid_t dxpl_id, size_t size, void *obj, H5HG_t *hobj/*out*/
         HGOTO_ERROR(H5E_HEAP, H5E_CANTPROTECT, FAIL, "unable to protect global heap")
 
     /* Split the free space to make room for the new object */
-    idx = H5HG_alloc(f, heap, size, &heap_flags);
+    if(0 == (idx = H5HG_alloc(f, heap, size, &heap_flags)))
+        HGOTO_ERROR(H5E_HEAP, H5E_CANTALLOC, FAIL, "unable to allocate global heap object")
 
     /* Copy data into the heap */
     if(size > 0) {
@@ -652,7 +657,7 @@ H5HG_insert(H5F_t *f, hid_t dxpl_id, size_t size, void *obj, H5HG_t *hobj/*out*/
 
 done:
     if(heap && H5AC_unprotect(f, dxpl_id, H5AC_GHEAP, heap->addr, heap, heap_flags) < 0)
-        HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to unprotect heap.")
+        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to unprotect heap.")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* H5HG_insert() */
@@ -731,7 +736,7 @@ H5HG_read(H5F_t *f, hid_t dxpl_id, H5HG_t *hobj, void *object/*out*/,
 
 done:
     if(heap && H5AC_unprotect(f, dxpl_id, H5AC_GHEAP, hobj->addr, heap, H5AC__NO_FLAGS_SET) < 0)
-        HDONE_ERROR(H5E_HEAP, H5E_PROTECT, NULL, "unable to release object header")
+        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, NULL, "unable to release object header")
 
     if(NULL == ret_value && NULL == orig_object && object)
         H5MM_free(object);
@@ -793,7 +798,7 @@ H5HG_link(H5F_t *f, hid_t dxpl_id, const H5HG_t *hobj, int adjust)
 
 done:
     if(heap && H5AC_unprotect(f, dxpl_id, H5AC_GHEAP, hobj->addr, heap, heap_flags) < 0)
-        HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release object header")
+        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release object header")
 
     FUNC_LEAVE_NOAPI(ret_value)
 } /* end H5HG_link() */
@@ -898,7 +903,7 @@ H5HG_remove (H5F_t *f, hid_t dxpl_id, H5HG_t *hobj)
 
 done:
     if(heap && H5AC_unprotect(f, dxpl_id, H5AC_GHEAP, hobj->addr, heap, flags) < 0)
-        HDONE_ERROR(H5E_HEAP, H5E_PROTECT, FAIL, "unable to release object header")
+        HDONE_ERROR(H5E_HEAP, H5E_CANTUNPROTECT, FAIL, "unable to release object header")
 
     FUNC_LEAVE_NOAPI(ret_value);
 } /* end H5HG_remove() */
diff --git a/src/H5HGpkg.h b/src/H5HGpkg.h
index f747897..6c60656 100644
--- a/src/H5HGpkg.h
+++ b/src/H5HGpkg.h
@@ -150,7 +150,7 @@ struct H5HG_heap_t {
 /* Package Private Prototypes */
 /******************************/
 H5_DLL herr_t H5HG_free(H5HG_heap_t *heap);
-H5_DLL H5HG_t *H5HG_protect(H5F_t *f, hid_t dxpl_id, haddr_t addr, H5AC_protect_t rw);
+H5_DLL H5HG_heap_t *H5HG_protect(H5F_t *f, hid_t dxpl_id, haddr_t addr, H5AC_protect_t rw);
 
 #endif /* _H5HGpkg_H */
 
diff --git a/src/H5MF.c b/src/H5MF.c
index 480f3bb..a8f12bb 100644
--- a/src/H5MF.c
+++ b/src/H5MF.c
@@ -905,7 +905,7 @@ done:
 
 
 /*-------------------------------------------------------------------------
- * Function:    H5MF_can_shrink
+ * Function:    H5MF_try_shrink
  *
  * Purpose:     Try to shrink the size of a file with a block or absorb it
  *              into a block aggregator.
diff --git a/src/H5O.c b/src/H5O.c
index 7e4a3dc..0971142 100644
--- a/src/H5O.c
+++ b/src/H5O.c
@@ -1793,7 +1793,7 @@ H5O_protect(const H5O_loc_t *loc, hid_t dxpl_id, H5AC_protect_t prot)
                         HGOTO_ERROR(H5E_OHDR, H5E_CANTPROTECT, NULL, "unable to load object header chunk")
 
                     /* Unprotect chunk, marking it dirty */
-                    if(H5O_chunk_unprotect(loc->file, dxpl_id, chk_proxy, H5AC__DIRTIED_FLAG) < 0)
+                    if(H5O_chunk_unprotect(loc->file, dxpl_id, chk_proxy, TRUE) < 0)
                         HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, NULL, "unable to unprotect object header chunk")
                 } /* end if */
             } /* end for */
@@ -1957,7 +1957,7 @@ herr_t
 H5O_touch_oh(H5F_t *f, hid_t dxpl_id, H5O_t *oh, hbool_t force)
 {
     H5O_chunk_proxy_t *chk_proxy = NULL;        /* Chunk that message is in */
-    unsigned chk_flags = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting chunk */
+    hbool_t chk_dirtied = FALSE;        /* Flag for unprotecting chunk */
     time_t	now;                    /* Current time */
     herr_t      ret_value = SUCCEED;    /* Return value */
 
@@ -2011,7 +2011,7 @@ H5O_touch_oh(H5F_t *f, hid_t dxpl_id, H5O_t *oh, hbool_t force)
 
             /* Mark the message as dirty */
             oh->mesg[idx].dirty = TRUE;
-            chk_flags |= H5AC__DIRTIED_FLAG;
+            chk_dirtied = TRUE;
         } /* end if */
         else {
             /* XXX: For now, update access time & change fields in the object header */
@@ -2026,7 +2026,7 @@ H5O_touch_oh(H5F_t *f, hid_t dxpl_id, H5O_t *oh, hbool_t force)
 
 done:
     /* Release chunk */
-    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_flags) < 0)
+    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_dirtied) < 0)
         HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
 
     FUNC_LEAVE_NOAPI(ret_value)
diff --git a/src/H5Oalloc.c b/src/H5Oalloc.c
index 186b7f4..1bdf277 100644
--- a/src/H5Oalloc.c
+++ b/src/H5Oalloc.c
@@ -59,8 +59,8 @@
 /********************/
 
 static herr_t H5O_add_gap(H5F_t *f, H5O_t *oh, unsigned chunkno,
-    unsigned *chk_flags, unsigned idx, uint8_t *new_gap_loc, size_t new_gap_size);
-static herr_t H5O_eliminate_gap(H5O_t *oh, unsigned *chk_flags,
+    hbool_t *chk_dirtied, unsigned idx, uint8_t *new_gap_loc, size_t new_gap_size);
+static herr_t H5O_eliminate_gap(H5O_t *oh, hbool_t *chk_dirtied,
     H5O_mesg_t *mesg, uint8_t *new_gap_loc, size_t new_gap_size);
 static herr_t H5O_alloc_null(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned null_idx,
     const H5O_msg_class_t *new_type, void *new_native, size_t new_size);
@@ -108,7 +108,7 @@ H5FL_EXTERN(H5O_cont_t);
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5O_add_gap(H5F_t *f, H5O_t *oh, unsigned chunkno, unsigned *chk_flags,
+H5O_add_gap(H5F_t *f, H5O_t *oh, unsigned chunkno, hbool_t *chk_dirtied,
     unsigned idx, uint8_t *new_gap_loc, size_t new_gap_size)
 {
     hbool_t merged_with_null;           /* Whether the gap was merged with a null message */
@@ -120,7 +120,7 @@ H5O_add_gap(H5F_t *f, H5O_t *oh, unsigned chunkno, unsigned *chk_flags,
     /* check args */
     HDassert(oh);
     HDassert(oh->version > H5O_VERSION_1);
-    HDassert(chk_flags);
+    HDassert(chk_dirtied);
     HDassert(new_gap_loc);
     HDassert(new_gap_size);
 
@@ -148,7 +148,7 @@ if(chunkno > 0) {
             HDassert(oh->chunk[chunkno].gap == 0);
 
             /* Eliminate the gap in the chunk */
-            if(H5O_eliminate_gap(oh, chk_flags, &oh->mesg[u], new_gap_loc, new_gap_size) < 0)
+            if(H5O_eliminate_gap(oh, chk_dirtied, &oh->mesg[u], new_gap_loc, new_gap_size) < 0)
                 HGOTO_ERROR(H5E_OHDR, H5E_CANTINSERT, FAIL, "can't eliminate gap in chunk")
 
             /* Set flag to indicate that the gap was handled */
@@ -205,7 +205,7 @@ if(chunkno > 0) {
             oh->chunk[chunkno].gap = new_gap_size;
 
         /* Mark the chunk as modified */
-        *chk_flags |= H5AC__DIRTIED_FLAG;
+        *chk_dirtied = TRUE;
     } /* end if */
 
 done:
@@ -234,18 +234,18 @@ done:
  *-------------------------------------------------------------------------
  */
 static herr_t
-H5O_eliminate_gap(H5O_t *oh, unsigned *chk_flags, H5O_mesg_t *mesg,
+H5O_eliminate_gap(H5O_t *oh, hbool_t *chk_dirtied, H5O_mesg_t *mesg,
     uint8_t *gap_loc, size_t gap_size)
 {
     uint8_t *move_start, *move_end;     /* Pointers to area of messages to move */
-    hbool_t null_before_gap;    /* Flag whether the null message is before the gap or not */
+    hbool_t null_before_gap;            /* Flag whether the null message is before the gap or not */
 
     FUNC_ENTER_NOAPI_NOINIT_NOFUNC(H5O_eliminate_gap)
 
     /* check args */
     HDassert(oh);
     HDassert(oh->version > H5O_VERSION_1);
-    HDassert(chk_flags);
+    HDassert(chk_dirtied);
     HDassert(mesg);
     HDassert(gap_loc);
     HDassert(gap_size);
@@ -314,7 +314,7 @@ H5O_eliminate_gap(H5O_t *oh, unsigned *chk_flags, H5O_mesg_t *mesg,
 
     /* Mark null message as dirty */
     mesg->dirty = TRUE;
-    *chk_flags |= H5AC__DIRTIED_FLAG;
+    *chk_dirtied = TRUE;
 
     FUNC_LEAVE_NOAPI(SUCCEED)
 } /* H5O_eliminate_gap() */
@@ -339,7 +339,7 @@ H5O_alloc_null(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned null_idx,
     const H5O_msg_class_t *new_type, void *new_native, size_t new_size)
 {
     H5O_chunk_proxy_t *chk_proxy = NULL;        /* Chunk that message is in */
-    unsigned chk_flags = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting chunk */
+    hbool_t chk_dirtied = FALSE;        /* Flags for unprotecting chunk */
     H5O_mesg_t *alloc_msg;              /* Pointer to null message to allocate out of */
     herr_t ret_value = SUCCEED; 	/* Return value */
 
@@ -367,7 +367,7 @@ H5O_alloc_null(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned null_idx,
             alloc_msg->raw_size = new_size;
 
             /* Add the gap to the chunk */
-            if(H5O_add_gap(f, oh, alloc_msg->chunkno, &chk_flags, null_idx, alloc_msg->raw + alloc_msg->raw_size, gap_size) < 0)
+            if(H5O_add_gap(f, oh, alloc_msg->chunkno, &chk_dirtied, null_idx, alloc_msg->raw + alloc_msg->raw_size, gap_size) < 0)
                 HGOTO_ERROR(H5E_OHDR, H5E_CANTINSERT, FAIL, "can't insert gap in chunk")
         } /* end if */
         else {
@@ -393,14 +393,14 @@ H5O_alloc_null(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned null_idx,
 
             /* Mark the message as dirty */
             null_msg->dirty = TRUE;
-            chk_flags |= H5AC__DIRTIED_FLAG;
+            chk_dirtied = TRUE;
 
             /* Check for gap in new null message's chunk */
             if(oh->chunk[null_msg->chunkno].gap > 0) {
                 unsigned null_chunkno = null_msg->chunkno;   /* Chunk w/gap */
 
                 /* Eliminate the gap in the chunk */
-                if(H5O_eliminate_gap(oh, &chk_flags, null_msg,
+                if(H5O_eliminate_gap(oh, &chk_dirtied, null_msg,
                         ((oh->chunk[null_chunkno].image + oh->chunk[null_chunkno].size) - (H5O_SIZEOF_CHKSUM_OH(oh) + oh->chunk[null_chunkno].gap)),
                         oh->chunk[null_chunkno].gap) < 0)
                     HGOTO_ERROR(H5E_OHDR, H5E_CANTREMOVE, FAIL, "can't eliminate gap in chunk")
@@ -417,11 +417,11 @@ H5O_alloc_null(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned null_idx,
 
     /* Mark the new message as dirty */
     alloc_msg->dirty = TRUE;
-    chk_flags |= H5AC__DIRTIED_FLAG;
+    chk_dirtied = TRUE;
 
 done:
     /* Release chunk */
-    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_flags) < 0)
+    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_dirtied) < 0)
         HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -507,8 +507,8 @@ static htri_t
 H5O_alloc_extend_chunk(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned chunkno,
     size_t size, int *msg_idx)
 {
-    H5O_chunk_proxy_t *chk_proxy = NULL;        /* Chunk that message is in */
-    unsigned chk_flags = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting chunk */
+    H5O_chunk_proxy_t *chk_proxy = NULL;    /* Chunk that message is in */
+    hbool_t     chk_dirtied = FALSE;        /* Flag for unprotecting chunk */
     size_t      delta;          /* Change in chunk's size */
     size_t      aligned_size = H5O_ALIGN_OH(oh, size);
     uint8_t     *old_image;     /* Old address of chunk's image in memory */
@@ -632,7 +632,7 @@ H5O_alloc_extend_chunk(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned chunkno,
 
     /* Mark the extended message as dirty */
     oh->mesg[extend_msg].dirty = TRUE;
-    chk_flags |= H5AC__DIRTIED_FLAG;
+    chk_dirtied = TRUE;
 
     /* Allocate more memory space for chunk's image */
     old_image = oh->chunk[chunkno].image;
@@ -663,8 +663,8 @@ H5O_alloc_extend_chunk(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned chunkno,
         if(chunkno > 0 && (H5O_CONT_ID == oh->mesg[u].type->id) &&
                 (((H5O_cont_t *)(oh->mesg[u].native))->chunkno == chunkno)) {
             H5O_chunk_proxy_t *chk_proxy2 = NULL;       /* Chunk that continuation message is in */
-            unsigned chk_flags2 = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting chunk */
             unsigned cont_chunkno = oh->mesg[u].chunkno;    /* Chunk # for continuation message */
+            hbool_t chk_dirtied2 = FALSE;               /* Flag for unprotecting chunk */
 
             /* Protect chunk containing continuation message */
             if(NULL == (chk_proxy2 = H5O_chunk_protect(f, dxpl_id, oh, cont_chunkno)))
@@ -676,23 +676,24 @@ H5O_alloc_extend_chunk(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned chunkno,
 
             /* Flag continuation message as dirty */
             oh->mesg[u].dirty = TRUE;
-            chk_flags2 |= H5AC__DIRTIED_FLAG;
+            chk_dirtied2 = TRUE;
 
             /* Release chunk containing continuation message */
-            if(H5O_chunk_unprotect(f, dxpl_id, chk_proxy2, chk_flags2) < 0)
+            if(H5O_chunk_unprotect(f, dxpl_id, chk_proxy2, chk_dirtied2) < 0)
                 HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
         } /* end if */
     } /* end for */
 
-    /* Mark the chunk size in the cache as changed */
-    chk_flags |= H5AC__SIZE_CHANGED_FLAG;
+    /* Resize the chunk in the cache */
+    if(H5O_chunk_resize(oh, chk_proxy) < 0)
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTRESIZE, FAIL, "unable to resize object header chunk")
 
     /* Set return value */
     *msg_idx = extend_msg;
 
 done:
     /* Release chunk */
-    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_flags) < 0)
+    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_dirtied) < 0)
         HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -993,7 +994,7 @@ H5O_alloc_new_chunk(H5F_t *f, hid_t dxpl_id, H5O_t *oh, size_t size)
         oh->chunk[chunkno - 1].gap = 0;
 
         /* Release chunk, marking it dirty */
-        if(H5O_chunk_unprotect(f, dxpl_id, chk_proxy, H5AC__DIRTIED_FLAG) < 0)
+        if(H5O_chunk_unprotect(f, dxpl_id, chk_proxy, TRUE) < 0)
             HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
     } else if(found_null < 0) {
         /* Move message (that will be replaced with continuation message)
@@ -1059,7 +1060,7 @@ H5O_alloc_new_chunk(H5F_t *f, hid_t dxpl_id, H5O_t *oh, size_t size)
         null_msg->dirty = TRUE;
 
         /* Release chunk, marking it dirty */
-        if(H5O_chunk_unprotect(f, dxpl_id, chk_proxy, H5AC__DIRTIED_FLAG) < 0)
+        if(H5O_chunk_unprotect(f, dxpl_id, chk_proxy, TRUE) < 0)
             HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
     } /* end if */
     HDassert(found_null >= 0);
@@ -1200,9 +1201,9 @@ herr_t
 H5O_release_mesg(H5F_t *f, hid_t dxpl_id, H5O_t *oh, H5O_mesg_t *mesg,
     hbool_t adj_link)
 {
-    H5O_chunk_proxy_t *chk_proxy = NULL;        /* Chunk that message is in */
-    unsigned chk_flags = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting chunk */
-    herr_t ret_value = SUCCEED; 	                /* Return value */
+    H5O_chunk_proxy_t *chk_proxy = NULL;    /* Chunk that message is in */
+    hbool_t chk_dirtied = FALSE;            /* Flag for unprotecting chunk */
+    herr_t ret_value = SUCCEED; 	    /* Return value */
 
     FUNC_ENTER_NOAPI(H5O_release_mesg, FAIL)
 
@@ -1235,12 +1236,12 @@ H5O_release_mesg(H5F_t *f, hid_t dxpl_id, H5O_t *oh, H5O_mesg_t *mesg,
 
     /* Mark the message as modified */
     mesg->dirty = TRUE;
-    chk_flags |= H5AC__DIRTIED_FLAG;
+    chk_dirtied = TRUE;
 
     /* Check if chunk has a gap currently */
     if(oh->chunk[mesg->chunkno].gap) {
         /* Eliminate the gap in the chunk */
-        if(H5O_eliminate_gap(oh, &chk_flags, mesg,
+        if(H5O_eliminate_gap(oh, &chk_dirtied, mesg,
                 ((oh->chunk[mesg->chunkno].image + oh->chunk[mesg->chunkno].size) - (H5O_SIZEOF_CHKSUM_OH(oh) + oh->chunk[mesg->chunkno].gap)),
                 oh->chunk[mesg->chunkno].gap) < 0)
             HGOTO_ERROR(H5E_OHDR, H5E_CANTREMOVE, FAIL, "can't eliminate gap in chunk")
@@ -1248,7 +1249,7 @@ H5O_release_mesg(H5F_t *f, hid_t dxpl_id, H5O_t *oh, H5O_mesg_t *mesg,
 
 done:
     /* Release chunk, if not already done */
-    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_flags) < 0)
+    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_dirtied) < 0)
         HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1274,7 +1275,7 @@ H5O_move_cont(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned cont_u)
     H5O_chunk_proxy_t *chk_proxy = NULL;        /* Chunk that continuation message is in */
     H5O_mesg_t 	*cont_msg;	/* Pointer to the continuation message */
     unsigned   	deleted_chunkno;       	/* Chunk # to delete */
-    unsigned    chk_flags = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting chunk */
+    hbool_t     chk_dirtied = FALSE;    /* Flags for unprotecting chunk */
     htri_t 	ret_value = TRUE;       /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5O_move_cont)
@@ -1353,7 +1354,7 @@ H5O_move_cont(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned cont_u)
                         curr_msg->raw = move_start + H5O_SIZEOF_MSGHDR_OH(oh);
                         curr_msg->chunkno = cont_chunkno;
                         curr_msg->dirty = TRUE;
-                        chk_flags |= H5AC__DIRTIED_FLAG;
+                        chk_dirtied = TRUE;
 
                         /* Adjust location to move messages to */
                         move_start += move_size;
@@ -1370,13 +1371,13 @@ H5O_move_cont(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned cont_u)
                 cont_msg->raw_size = gap_size - H5O_SIZEOF_MSGHDR_OH(oh);
                 cont_msg->raw = move_start + H5O_SIZEOF_MSGHDR_OH(oh);
                 cont_msg->dirty = TRUE;
-                chk_flags |= H5AC__DIRTIED_FLAG;
+                chk_dirtied = TRUE;
             } /* end if */
             else {
                 /* Check if there is space that should be a gap */
                 if(gap_size > 0) {
                     /* Convert remnant into gap in chunk */
-                    if(H5O_add_gap(f, oh, cont_chunkno, &chk_flags, cont_u, move_start, gap_size) < 0)
+                    if(H5O_add_gap(f, oh, cont_chunkno, &chk_dirtied, cont_u, move_start, gap_size) < 0)
                         HGOTO_ERROR(H5E_OHDR, H5E_CANTINSERT, FAIL, "can't insert gap in chunk")
                 } /* end if */
 
@@ -1396,7 +1397,7 @@ H5O_move_cont(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned cont_u)
                     if(curr_msg->type->id == H5O_NULL_ID) {
                         /* Release any information/memory for message */
                         H5O_msg_free_mesg(curr_msg);
-                        chk_flags |= H5AC__DIRTIED_FLAG;
+                        chk_dirtied = TRUE;
 
                         /* Remove from message list */
                         if(v < (oh->nmesgs - 1))
@@ -1417,7 +1418,7 @@ H5O_move_cont(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned cont_u)
 
 done:
     /* Release chunk, if not already done */
-    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_flags) < 0)
+    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_dirtied) < 0)
         HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1503,7 +1504,7 @@ H5O_move_msgs_forward(H5F_t *f, hid_t dxpl_id, H5O_t *oh)
                                 curr_msg->dirty = TRUE;
 
                                 /* Release chunk, marking it dirty */
-                                if(H5O_chunk_unprotect(f, dxpl_id, null_chk_proxy, H5AC__DIRTIED_FLAG) < 0)
+                                if(H5O_chunk_unprotect(f, dxpl_id, null_chk_proxy, TRUE) < 0)
                                     HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
 
                                 /* Set the flag to indicate that the null message
@@ -1543,10 +1544,10 @@ H5O_move_msgs_forward(H5F_t *f, hid_t dxpl_id, H5O_t *oh)
                     for(v = 0, null_msg = &oh->mesg[0]; v < oh->nmesgs; v++, null_msg++) {
                         if(H5O_NULL_ID == null_msg->type->id && curr_msg->chunkno > null_msg->chunkno
                                 && curr_msg->raw_size <= null_msg->raw_size) {
-                            H5O_chunk_proxy_t *null_chk_proxy;        /* Chunk that null message is in */
-                            H5O_chunk_proxy_t *curr_chk_proxy;        /* Chunk that message is in */
-                            unsigned null_chk_flags = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting null chunk */
-                            unsigned curr_chk_flags = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting curr chunk */
+                            H5O_chunk_proxy_t *null_chk_proxy;  /* Chunk that null message is in */
+                            H5O_chunk_proxy_t *curr_chk_proxy;  /* Chunk that message is in */
+                            unsigned null_chk_dirtied = FALSE;  /* Flags for unprotecting null chunk */
+                            unsigned curr_chk_dirtied = FALSE;  /* Flags for unprotecting curr chunk */
                             unsigned old_chunkno;   /* Old message information */
                             uint8_t *old_raw;
 
@@ -1566,7 +1567,7 @@ H5O_move_msgs_forward(H5F_t *f, hid_t dxpl_id, H5O_t *oh)
                             /* Point non-null message at null message's space */
                             curr_msg->chunkno = null_msg->chunkno;
                             curr_msg->raw = null_msg->raw;
-                            curr_chk_flags |= H5AC__DIRTIED_FLAG;
+                            curr_chk_dirtied = TRUE;
 
                             /* Change information for null message */
                             if(curr_msg->raw_size == null_msg->raw_size) {
@@ -1577,23 +1578,23 @@ H5O_move_msgs_forward(H5F_t *f, hid_t dxpl_id, H5O_t *oh)
 
                                 /* Mark null message dirty */
                                 null_msg->dirty = TRUE;
-                                null_chk_flags |= H5AC__DIRTIED_FLAG;
+                                null_chk_dirtied = TRUE;
 
                                 /* Release current chunk, marking it dirty */
-                                if(H5O_chunk_unprotect(f, dxpl_id, curr_chk_proxy, curr_chk_flags) < 0)
+                                if(H5O_chunk_unprotect(f, dxpl_id, curr_chk_proxy, curr_chk_dirtied) < 0)
                                     HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
 
                                 /* Check for gap in null message's chunk */
                                 if(oh->chunk[old_chunkno].gap > 0) {
                                     /* Eliminate the gap in the chunk */
-                                    if(H5O_eliminate_gap(oh, &null_chk_flags, null_msg,
+                                    if(H5O_eliminate_gap(oh, &null_chk_dirtied, null_msg,
                                             ((oh->chunk[old_chunkno].image + oh->chunk[old_chunkno].size) - (H5O_SIZEOF_CHKSUM_OH(oh) + oh->chunk[old_chunkno].gap)),
                                             oh->chunk[old_chunkno].gap) < 0)
                                         HGOTO_ERROR(H5E_OHDR, H5E_CANTREMOVE, FAIL, "can't eliminate gap in chunk")
                                 } /* end if */
 
                                 /* Release null chunk, marking it dirty */
-                                if(H5O_chunk_unprotect(f, dxpl_id, null_chk_proxy, null_chk_flags) < 0)
+                                if(H5O_chunk_unprotect(f, dxpl_id, null_chk_proxy, null_chk_dirtied) < 0)
                                     HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
                             } /* end if */
                             else {
@@ -1608,10 +1609,10 @@ H5O_move_msgs_forward(H5F_t *f, hid_t dxpl_id, H5O_t *oh)
 
                                     /* Mark null message dirty */
                                     null_msg->dirty = TRUE;
-                                    null_chk_flags |= H5AC__DIRTIED_FLAG;
+                                    null_chk_dirtied = TRUE;
 
                                     /* Add the gap to the chunk */
-                                    if(H5O_add_gap(f, oh, null_msg->chunkno, &null_chk_flags, v, null_msg->raw + null_msg->raw_size, gap_size) < 0)
+                                    if(H5O_add_gap(f, oh, null_msg->chunkno, &null_chk_dirtied, v, null_msg->raw + null_msg->raw_size, gap_size) < 0)
                                         HGOTO_ERROR(H5E_OHDR, H5E_CANTINSERT, FAIL, "can't insert gap in chunk")
 
                                     /* Re-use message # for new null message taking place of non-null message */
@@ -1624,7 +1625,7 @@ H5O_move_msgs_forward(H5F_t *f, hid_t dxpl_id, H5O_t *oh)
 
                                     /* Mark null message dirty */
                                     null_msg->dirty = TRUE;
-                                    null_chk_flags |= H5AC__DIRTIED_FLAG;
+                                    null_chk_dirtied = TRUE;
 
                                     /* Create new null message for previous location of non-null message */
                                     if(oh->nmesgs >= oh->alloc_nmesgs) {
@@ -1640,7 +1641,7 @@ H5O_move_msgs_forward(H5F_t *f, hid_t dxpl_id, H5O_t *oh)
                                 } /* end else */
 
                                 /* Release null message's chunk, marking it dirty */
-                                if(H5O_chunk_unprotect(f, dxpl_id, null_chk_proxy, null_chk_flags) < 0)
+                                if(H5O_chunk_unprotect(f, dxpl_id, null_chk_proxy, null_chk_dirtied) < 0)
                                     HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
 
                                 /* Initialize new null message to take over non-null message's location */
@@ -1652,19 +1653,19 @@ H5O_move_msgs_forward(H5F_t *f, hid_t dxpl_id, H5O_t *oh)
 
                                 /* Mark new null message dirty */
                                 oh->mesg[new_null_msg].dirty = TRUE;
-                                curr_chk_flags |= H5AC__DIRTIED_FLAG;
+                                curr_chk_dirtied = TRUE;
 
                                 /* Check for gap in new null message's chunk */
                                 if(oh->chunk[old_chunkno].gap > 0) {
                                     /* Eliminate the gap in the chunk */
-                                    if(H5O_eliminate_gap(oh, &curr_chk_flags, &oh->mesg[new_null_msg],
+                                    if(H5O_eliminate_gap(oh, &curr_chk_dirtied, &oh->mesg[new_null_msg],
                                             ((oh->chunk[old_chunkno].image + oh->chunk[old_chunkno].size) - (H5O_SIZEOF_CHKSUM_OH(oh) + oh->chunk[old_chunkno].gap)),
                                             oh->chunk[old_chunkno].gap) < 0)
                                         HGOTO_ERROR(H5E_OHDR, H5E_CANTREMOVE, FAIL, "can't eliminate gap in chunk")
                                 } /* end if */
 
                                 /* Release new null message's chunk, marking it dirty */
-                                if(H5O_chunk_unprotect(f, dxpl_id, curr_chk_proxy, curr_chk_flags) < 0)
+                                if(H5O_chunk_unprotect(f, dxpl_id, curr_chk_proxy, curr_chk_dirtied) < 0)
                                     HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
                             } /* end else */
 
@@ -1790,7 +1791,7 @@ H5O_merge_null(H5F_t *f, hid_t dxpl_id, H5O_t *oh)
                             curr_msg->dirty = TRUE;
 
                             /* Release new null message's chunk, marking it dirty */
-                            if(H5O_chunk_unprotect(f, dxpl_id, curr_chk_proxy, H5AC__DIRTIED_FLAG) < 0)
+                            if(H5O_chunk_unprotect(f, dxpl_id, curr_chk_proxy, TRUE) < 0)
                                 HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
 
                             /* Remove second message from list of messages */
@@ -2263,20 +2264,24 @@ H5O_alloc_shrink_chunk(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned chunkno)
             curr_msg->dirty = TRUE;
 
             /* Release chunk, marking it dirty */
-            if(H5O_chunk_unprotect(f, dxpl_id, cont_chk_proxy, H5AC__DIRTIED_FLAG) < 0)
+            if(H5O_chunk_unprotect(f, dxpl_id, cont_chk_proxy, TRUE) < 0)
                 HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
         } /* end if */
     } /* end for */
 
     HDassert(new_size <= old_size);
 
+    /* Resize the chunk in the cache */
+    if(H5O_chunk_resize(oh, chk_proxy) < 0)
+        HGOTO_ERROR(H5E_OHDR, H5E_CANTRESIZE, FAIL, "unable to resize object header chunk")
+
     /* Free the unused space in the file */
     if(H5MF_xfree(f, H5FD_MEM_OHDR, dxpl_id, chunk->addr + new_size, (hsize_t)(old_size - new_size)) < 0)
         HGOTO_ERROR(H5E_OHDR, H5E_CANTFREE, FAIL, "unable to shrink object header chunk")
 
 done:
     /* Release chunk, marking it dirty */
-    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, H5AC__DIRTIED_FLAG) < 0)
+    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, TRUE) < 0)
         HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to unprotect object header chunk")
 
     FUNC_LEAVE_NOAPI(ret_value)
diff --git a/src/H5Oattribute.c b/src/H5Oattribute.c
index d2b5811..8260379 100644
--- a/src/H5Oattribute.c
+++ b/src/H5Oattribute.c
@@ -833,8 +833,8 @@ H5O_attr_write_cb(H5O_t *oh, H5O_mesg_t *mesg/*in,out*/,
 {
     H5O_iter_wrt_t *udata = (H5O_iter_wrt_t *)_udata;   /* Operator user data */
     H5O_chunk_proxy_t *chk_proxy = NULL;        /* Chunk that message is in */
-    unsigned chk_flags = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting chunk */
-    herr_t ret_value = H5_ITER_CONT;   /* Return value */
+    hbool_t chk_dirtied = FALSE;        /* Flag for unprotecting chunk */
+    herr_t ret_value = H5_ITER_CONT;    /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5O_attr_write_cb)
 
@@ -862,10 +862,10 @@ H5O_attr_write_cb(H5O_t *oh, H5O_mesg_t *mesg/*in,out*/,
 
         /* Mark the message as modified */
         mesg->dirty = TRUE;
-        chk_flags |= H5AC__DIRTIED_FLAG;
+        chk_dirtied = TRUE;
 
         /* Release chunk */
-        if(H5O_chunk_unprotect(udata->f, udata->dxpl_id, chk_proxy, chk_flags) < 0)
+        if(H5O_chunk_unprotect(udata->f, udata->dxpl_id, chk_proxy, chk_dirtied) < 0)
             HGOTO_ERROR(H5E_ATTR, H5E_CANTUNPROTECT, H5_ITER_ERROR, "unable to unprotect object header chunk")
         chk_proxy = NULL;
 
@@ -886,7 +886,7 @@ H5O_attr_write_cb(H5O_t *oh, H5O_mesg_t *mesg/*in,out*/,
 
 done:
     /* Release chunk, if not already done */
-    if(chk_proxy && H5O_chunk_unprotect(udata->f, udata->dxpl_id, chk_proxy, chk_flags) < 0)
+    if(chk_proxy && H5O_chunk_unprotect(udata->f, udata->dxpl_id, chk_proxy, chk_dirtied) < 0)
         HDONE_ERROR(H5E_ATTR, H5E_CANTUNPROTECT, H5_ITER_ERROR, "unable to unprotect object header chunk")
 
     FUNC_LEAVE_NOAPI(ret_value)
@@ -1035,8 +1035,8 @@ H5O_attr_rename_mod_cb(H5O_t *oh, H5O_mesg_t *mesg/*in,out*/,
 {
     H5O_iter_ren_t *udata = (H5O_iter_ren_t *)_udata;   /* Operator user data */
     H5O_chunk_proxy_t *chk_proxy = NULL;        /* Chunk that message is in */
-    unsigned chk_flags = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting chunk */
-    herr_t ret_value = H5_ITER_CONT;   /* Return value */
+    hbool_t chk_dirtied = FALSE;        /* Flags for unprotecting chunk */
+    herr_t ret_value = H5_ITER_CONT;    /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5O_attr_rename_mod_cb)
 
@@ -1063,10 +1063,10 @@ H5O_attr_rename_mod_cb(H5O_t *oh, H5O_mesg_t *mesg/*in,out*/,
 
         /* Mark the message as modified */
         mesg->dirty = TRUE;
-        chk_flags |= H5AC__DIRTIED_FLAG;
+        chk_dirtied = TRUE;
 
         /* Release chunk */
-        if(H5O_chunk_unprotect(udata->f, udata->dxpl_id, chk_proxy, chk_flags) < 0)
+        if(H5O_chunk_unprotect(udata->f, udata->dxpl_id, chk_proxy, chk_dirtied) < 0)
             HGOTO_ERROR(H5E_ATTR, H5E_CANTUNPROTECT, H5_ITER_ERROR, "unable to unprotect object header chunk")
         chk_proxy = NULL;
 
@@ -1130,7 +1130,7 @@ H5O_attr_rename_mod_cb(H5O_t *oh, H5O_mesg_t *mesg/*in,out*/,
 
 done:
     /* Release chunk, if not already done */
-    if(chk_proxy && H5O_chunk_unprotect(udata->f, udata->dxpl_id, chk_proxy, chk_flags) < 0)
+    if(chk_proxy && H5O_chunk_unprotect(udata->f, udata->dxpl_id, chk_proxy, chk_dirtied) < 0)
         HDONE_ERROR(H5E_ATTR, H5E_CANTUNPROTECT, H5_ITER_ERROR, "unable to unprotect object header chunk")
 
     FUNC_LEAVE_NOAPI(ret_value)
diff --git a/src/H5Ochunk.c b/src/H5Ochunk.c
index 5fba81b..a137d54 100644
--- a/src/H5Ochunk.c
+++ b/src/H5Ochunk.c
@@ -216,7 +216,7 @@ done:
  */
 herr_t
 H5O_chunk_unprotect(H5F_t *f, hid_t dxpl_id, H5O_chunk_proxy_t *chk_proxy,
-    unsigned chk_flags)
+    hbool_t dirtied)
 {
     herr_t ret_value = SUCCEED;        /* Return value */
 
@@ -225,19 +225,11 @@ H5O_chunk_unprotect(H5F_t *f, hid_t dxpl_id, H5O_chunk_proxy_t *chk_proxy,
     /* check args */
     HDassert(f);
     HDassert(chk_proxy);
-    HDassert(!(chk_flags & (unsigned)~(H5AC__DIRTIED_FLAG | H5AC__SIZE_CHANGED_FLAG)));
 
     /* Check for releasing first chunk */
     if(0 == chk_proxy->chunkno) {
-        /* Check for resizing the first chunk */
-        if(chk_flags & H5AC__SIZE_CHANGED_FLAG) {
-            /* Resize object header in cache */
-            if(H5AC_resize_entry(chk_proxy->oh, chk_proxy->oh->chunk[0].size) < 0)
-                HGOTO_ERROR(H5E_OHDR, H5E_CANTRESIZE, FAIL, "unable to resize chunk in cache")
-        } /* end if */
-
         /* Check for dirtying the first chunk */
-        if(chk_flags & H5AC__DIRTIED_FLAG) {
+        if(dirtied) {
             /* Mark object header as dirty in cache */
             if(H5AC_mark_entry_dirty(chk_proxy->oh) < 0)
                 HGOTO_ERROR(H5E_OHDR, H5E_CANTMARKDIRTY, FAIL, "unable to mark object header as dirty")
@@ -252,7 +244,7 @@ H5O_chunk_unprotect(H5F_t *f, hid_t dxpl_id, H5O_chunk_proxy_t *chk_proxy,
     } /* end if */
     else {
         /* Release the chunk proxy from the cache, marking it dirty */
-        if(H5AC_unprotect(f, dxpl_id, H5AC_OHDR_CHK, chk_proxy->oh->chunk[chk_proxy->chunkno].addr, chk_proxy, chk_flags) < 0)
+        if(H5AC_unprotect(f, dxpl_id, H5AC_OHDR_CHK, chk_proxy->oh->chunk[chk_proxy->chunkno].addr, chk_proxy, (dirtied ? H5AC__DIRTIED_FLAG : H5AC__NO_FLAGS_SET)) < 0)
             HGOTO_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to release object header chunk")
     } /* end else */
 
@@ -262,6 +254,48 @@ done:
 
 
 /*-------------------------------------------------------------------------
+ * Function:	H5O_chunk_resize
+ *
+ * Purpose:	Resize an object header chunk
+ *
+ * Return:	Success:	Non-negative
+ *		Failure:	Negative
+ *
+ * Programmer:	Quincey Koziol
+ *		koziol@hdfgroup.org
+ *		May  6 2010
+ *
+ *-------------------------------------------------------------------------
+ */
+herr_t
+H5O_chunk_resize(H5O_t *oh, H5O_chunk_proxy_t *chk_proxy)
+{
+    herr_t ret_value = SUCCEED;        /* Return value */
+
+    FUNC_ENTER_NOAPI(H5O_chunk_resize, FAIL)
+
+    /* check args */
+    HDassert(oh);
+    HDassert(chk_proxy);
+
+    /* Check for resizing first chunk */
+    if(0 == chk_proxy->chunkno) {
+        /* Resize object header in cache */
+        if(H5AC_resize_entry(oh, oh->chunk[0].size) < 0)
+            HGOTO_ERROR(H5E_OHDR, H5E_CANTRESIZE, FAIL, "unable to resize chunk in cache")
+    } /* end if */
+    else {
+        /* Resize chunk in cache */
+        if(H5AC_resize_entry(chk_proxy, oh->chunk[chk_proxy->chunkno].size) < 0)
+            HGOTO_ERROR(H5E_OHDR, H5E_CANTRESIZE, FAIL, "unable to resize chunk in cache")
+    } /* end else */
+
+done:
+    FUNC_LEAVE_NOAPI(ret_value)
+} /* end H5O_chunk_resize() */
+
+
+/*-------------------------------------------------------------------------
  * Function:	H5O_chunk_update_idx
  *
  * Purpose:	Update the chunk index for a chunk proxy
diff --git a/src/H5Omessage.c b/src/H5Omessage.c
index fbf0761..62a1e1c 100644
--- a/src/H5Omessage.c
+++ b/src/H5Omessage.c
@@ -1956,7 +1956,7 @@ H5O_copy_mesg(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned idx,
 {
     H5O_chunk_proxy_t *chk_proxy = NULL;        /* Chunk that message is in */
     H5O_mesg_t *idx_msg = &oh->mesg[idx];       /* Pointer to message to modify */
-    unsigned chk_flags = H5AC__NO_FLAGS_SET;   /* Flags for unprotecting chunk */
+    hbool_t chk_dirtied = FALSE;                /* Flag for unprotecting chunk */
     herr_t      ret_value = SUCCEED;            /* Return value */
 
     FUNC_ENTER_NOAPI_NOINIT(H5O_copy_mesg)
@@ -1984,10 +1984,10 @@ H5O_copy_mesg(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned idx,
 
     /* Mark the message as modified */
     idx_msg->dirty = TRUE;
-    chk_flags |= H5AC__DIRTIED_FLAG;
+    chk_dirtied = TRUE;
 
     /* Release chunk */
-    if(H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_flags) < 0)
+    if(H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_dirtied) < 0)
         HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to release object header chunk")
     chk_proxy = NULL;
 
@@ -1998,7 +1998,7 @@ H5O_copy_mesg(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned idx,
 
 done:
     /* Release chunk, if not already released */
-    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_flags) < 0)
+    if(chk_proxy && H5O_chunk_unprotect(f, dxpl_id, chk_proxy, chk_dirtied) < 0)
         HDONE_ERROR(H5E_OHDR, H5E_CANTUNPROTECT, FAIL, "unable to release object header chunk")
 
     FUNC_LEAVE_NOAPI(ret_value)
diff --git a/src/H5Opkg.h b/src/H5Opkg.h
index a1a6461..f4fba45 100644
--- a/src/H5Opkg.h
+++ b/src/H5Opkg.h
@@ -556,8 +556,9 @@ H5_DLL herr_t H5O_chunk_add(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned idx);
 H5_DLL H5O_chunk_proxy_t *H5O_chunk_protect(H5F_t *f, hid_t dxpl_id, H5O_t *oh,
     unsigned idx);
 H5_DLL herr_t H5O_chunk_unprotect(H5F_t *f, hid_t dxpl_id,
-    H5O_chunk_proxy_t *chk_proxy, unsigned chk_flags);
+    H5O_chunk_proxy_t *chk_proxy, hbool_t chk_dirtied);
 H5_DLL herr_t H5O_chunk_update_idx(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned idx);
+H5_DLL herr_t H5O_chunk_resize(H5O_t *oh, H5O_chunk_proxy_t *chk_proxy);
 H5_DLL herr_t H5O_chunk_delete(H5F_t *f, hid_t dxpl_id, H5O_t *oh, unsigned idx);
 
 /* Collect storage info for btree and heap */